integrate api into frontend.

.gitignore

@@ -1,8 +1,7 @@
-.DS_Store
-node_modules
 /build
-/.svelte-kit
 /package
 .env
 .env.*
 !.env.example
+.idea
+.vscode

api/common.go

@@ -0,0 +1,100 @@
+package api
+
+import (
+	"context"
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/auth"
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/database"
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/models"
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/slerrors"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strconv"
+	"strings"
+)
+
+func handler(key string, callback func(c *gin.Context) (interface{}, error)) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		res, err := callback(c)
+		if err != nil {
+			slerrors.Respond(c, err)
+			return
+		}
+
+		resJson := make(map[string]interface{}, 1)
+
+		if s := getScope(c); s != nil {
+			options := ScopeOptions{
+				StatusLabels: models.StatusLabels,
+			}
+
+			if s.Stats != nil && !strings.Contains(c.FullPath(), "/stats/") {
+				options.Stats = make(map[int]models.Stat)
+				for _, stat := range s.Stats {
+					options.Stats[stat.ID] = stat
+				}
+			}
+			options.Members = make(map[string]string)
+			for _, member := range s.Members {
+				options.Members[member.ID] = member.Name
+			}
+			resJson["scopeInfo"] = options
+		}
+		resJson[key] = res
+
+		c.JSON(200, resJson)
+	}
+}
+
+type ScopeOptions struct {
+	StatusLabels map[models.Status]string `json:"statusLabels"`
+	Stats        map[int]models.Stat      `json:"stats,omitempty"`
+	Members      map[string]string        `json:"members,omitempty"`
+}
+
+func reqInt(c *gin.Context, key string) (int, error) {
+	v, err := strconv.Atoi(c.Param(key))
+	if err != nil {
+		return 0, slerrors.BadRequest(key + " parameter must be a number")
+	}
+
+	return v, nil
+}
+
+var scopeIdContextKey = struct{ stuff string }{stuff: "Things"}
+
+func scopeIDMiddleware(db database.Database) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		scopeID, err := strconv.Atoi(c.Param("scope_id"))
+		if err != nil {
+			c.AbortWithStatusJSON(http.StatusUnauthorized, slerrors.ErrorResponse{
+				Code:    http.StatusBadRequest,
+				Message: "Invalid scope ID in path!",
+			})
+
+			return
+		}
+
+		scope, err := db.Scopes().Find(c.Request.Context(), scopeID, strings.Contains(c.FullPath(), "/stats/") || c.Request.Method != "GET")
+		if err != nil || !scope.HasMember(auth.UserID(c)) {
+			c.AbortWithStatusJSON(http.StatusUnauthorized, slerrors.ErrorResponse{
+				Code:    http.StatusNotFound,
+				Message: "Scope not found or you don't have permission to it!",
+			})
+
+			return
+		}
+
+		c.Request = c.Request.WithContext(
+			context.WithValue(c.Request.Context(), &scopeIdContextKey, scope),
+		)
+	}
+}
+
+func getScope(c *gin.Context) *models.Scope {
+	scope := c.Request.Context().Value(&scopeIdContextKey)
+	if scope == nil {
+		return nil
+	}
+
+	return scope.(*models.Scope)
+}

api/items.go

@@ -0,0 +1,165 @@
+package api
+
+import (
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/auth"
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/database"
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/models"
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/slerrors"
+	"github.com/gin-gonic/gin"
+	"time"
+)
+
+func Items(g *gin.RouterGroup, db database.Database) {
+	g.Use(scopeIDMiddleware(db))
+
+	g.GET("", handler("items", func(c *gin.Context) (res interface{}, err error) {
+		mode := c.Query("mode")
+
+		var fromTime, toTime time.Time
+		var fromDate, toDate models.Date
+		if mode != "scheduled" {
+			if c.Query("to") == "" {
+				toTime = time.Now()
+			} else {
+				toTime, err = time.Parse(time.RFC3339Nano, c.Query("to"))
+				if err != nil {
+					return nil, slerrors.BadRequest("Invalid value for to")
+				}
+			}
+			if c.Query("from") == "" {
+				fromTime = time.Now().Add(-time.Hour * 24 * 30)
+			} else {
+				fromTime, err = time.Parse(time.RFC3339Nano, c.Query("from"))
+				if err != nil {
+					return nil, slerrors.BadRequest("Invalid value for from")
+				}
+			}
+			if toTime.After(toTime) {
+				return nil, slerrors.BadRequest("the flow of time itself is convoluted, but not so for the database")
+			}
+		} else {
+			if c.Query("to") == "" {
+				toDate, _ = models.ParseDate(time.Now().Add(time.Hour * 24 * 7).Format("2006-01-02"))
+			} else {
+				toDate, err = models.ParseDate(c.Query("to"))
+				if err != nil {
+					return nil, slerrors.BadRequest("Invalid value for to")
+				}
+			}
+			if c.Query("from") == "" {
+				fromDate, _ = models.ParseDate(time.Now().Format("2006-01-02"))
+			} else {
+				fromDate, err = models.ParseDate(c.Query("from"))
+				if err != nil {
+					return nil, slerrors.BadRequest("Invalid value for from")
+				}
+			}
+		}
+
+		switch mode {
+		case "", "created":
+			return db.Items(getScope(c).ID).ListCreated(c.Request.Context(), fromTime, toTime)
+		case "acquired":
+			return db.Items(getScope(c).ID).ListAcquired(c.Request.Context(), fromTime, toTime)
+		case "loose":
+			return db.Items(getScope(c).ID).ListLoose(c.Request.Context(), fromTime, toTime)
+		case "scheduled":
+			return db.Items(getScope(c).ID).ListScheduled(c.Request.Context(), fromDate, toDate)
+		default:
+			return nil, slerrors.BadRequest("unknown mode")
+		}
+	}))
+
+	g.GET("/:id", handler("item", func(c *gin.Context) (interface{}, error) {
+		id, err := reqInt(c, "id")
+		if err != nil {
+			return nil, err
+		}
+
+		return db.Items(getScope(c).ID).Find(c.Request.Context(), id)
+	}))
+
+	g.POST("", handler("item", func(c *gin.Context) (interface{}, error) {
+		item := &models.Item{}
+		err := c.BindJSON(item)
+		if err != nil {
+			return nil, slerrors.BadRequest("Invalid JSON input: " + err.Error())
+		}
+
+		item.CreatedTime = time.Now()
+
+		if item.Name == "" {
+			return nil, slerrors.BadRequest("Blank item name not allowed")
+		}
+		if item.OwnerID == "" {
+			item.OwnerID = auth.UserID(c)
+		} else if getScope(c).HasMember(item.OwnerID) {
+			return nil, slerrors.Forbidden("Owner is not part of scope.")
+		}
+		for _, stat := range item.Stats {
+			if getScope(c).Stat(stat.ID) == nil {
+				return nil, slerrors.Forbidden("One or more stats are not part of scope.")
+			}
+			if stat.Acquired == 0 && stat.Required == 0 {
+				return nil, slerrors.BadRequest("0/0 stats are not allowed when creating items.")
+			}
+		}
+
+		return db.Items(getScope(c).ID).Create(c.Request.Context(), *item)
+	}))
+
+	g.PUT("/:id", handler("item", func(c *gin.Context) (interface{}, error) {
+		id, err := reqInt(c, "id")
+		if err != nil {
+			return nil, err
+		}
+
+		update := &models.ItemUpdate{}
+		err = c.BindJSON(update)
+		if err != nil {
+			return nil, slerrors.BadRequest("Invalid JSON input: " + err.Error())
+		}
+
+		item, err := db.Items(getScope(c).ID).Find(c.Request.Context(), id)
+		if err != nil {
+			return nil, err
+		}
+
+		if update.Name != nil && *update.Name == "" {
+			return nil, slerrors.BadRequest("Blank item name not allowed")
+		}
+		if update.OwnerID != nil || !getScope(c).HasMember(item.OwnerID) {
+			return nil, slerrors.Forbidden("New item is not part of scope.")
+		}
+		for _, stat := range update.Stats {
+			statRef := getScope(c).Stat(stat.ID)
+			if stat.Required != 0 && stat.Acquired != 0 && statRef == nil {
+				return nil, slerrors.Forbidden("One or more stats are not part of the scope.")
+			}
+			if !statRef.AllowsAmount(stat.Required) {
+				return nil, slerrors.Forbidden("One or more stats have a disallowed required amount.")
+			}
+		}
+
+		return db.Items(getScope(c).ID).Update(c.Request.Context(), *item, *update)
+	}))
+
+	g.DELETE("/:id", handler("item", func(c *gin.Context) (interface{}, error) {
+		id, err := reqInt(c, "id")
+		if err != nil {
+			return nil, err
+		}
+
+		item, err := db.Items(getScope(c).ID).Find(c.Request.Context(), id)
+		if err != nil {
+			return nil, err
+		}
+
+		err = db.Items(getScope(c).ID).Delete(c.Request.Context(), *item)
+		if err != nil {
+			return nil, err
+		}
+
+		return item, nil
+	}))
+}

api/projects.go

@@ -0,0 +1,188 @@
+package api
+
+import (
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/auth"
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/database"
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/models"
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/slerrors"
+	"github.com/gin-gonic/gin"
+	"time"
+)
+
+func Projects(g *gin.RouterGroup, db database.Database) {
+	g.Use(scopeIDMiddleware(db))
+
+	g.GET("", handler("projects", func(c *gin.Context) (interface{}, error) {
+		return db.Projects(getScope(c).ID).List(c.Request.Context())
+	}))
+
+	g.GET("/:id", handler("project", func(c *gin.Context) (interface{}, error) {
+		id, err := reqInt(c, "id")
+		if err != nil {
+			return nil, err
+		}
+
+		return db.Projects(getScope(c).ID).Find(c.Request.Context(), id)
+	}))
+
+	g.POST("", handler("project", func(c *gin.Context) (interface{}, error) {
+		project := &models.Project{}
+		err := c.BindJSON(project)
+		if err != nil {
+			return nil, slerrors.BadRequest("Invalid JSON input: " + err.Error())
+		}
+
+		if !project.Status.Valid() {
+			return nil, slerrors.BadRequest("Unknown/unsupported project status")
+		}
+		if project.Name == "" {
+			return nil, slerrors.BadRequest("Project name cannot be blank")
+		}
+		if len(project.Requirements) > 0 {
+			return nil, slerrors.BadRequest("You cannot submit requirements this way")
+		}
+
+		project.OwnerID = auth.UserID(c)
+		project.CreatedTime = time.Now()
+
+		return db.Projects(getScope(c).ID).Create(c.Request.Context(), *project)
+	}))
+
+	g.PUT("/:id", handler("project", func(c *gin.Context) (interface{}, error) {
+		id, err := reqInt(c, "id")
+		if err != nil {
+			return nil, err
+		}
+
+		update := &models.ProjectUpdate{}
+		err = c.BindJSON(update)
+		if err != nil {
+			return nil, slerrors.BadRequest("Invalid JSON input: " + err.Error())
+		}
+
+		project, err := db.Projects(getScope(c).ID).Find(c.Request.Context(), id)
+		if err != nil {
+			return nil, err
+		}
+
+		return db.Projects(getScope(c).ID).Update(c.Request.Context(), *project, *update)
+	}))
+
+	g.POST("/:id/requirements", handler("project", func(c *gin.Context) (interface{}, error) {
+		id, err := reqInt(c, "id")
+		if err != nil {
+			return nil, err
+		}
+
+		requirement := &models.ProjectRequirement{}
+		err = c.BindJSON(requirement)
+		if err != nil {
+			return nil, slerrors.BadRequest("Invalid JSON input: " + err.Error())
+		}
+
+		if requirement.Name == "" {
+			return nil, slerrors.BadRequest("Requirement name cannot be empty.")
+		}
+		if !requirement.Status.Valid() {
+			return nil, slerrors.BadRequest("Bad requirement status.")
+		}
+		for _, stat := range requirement.Stats {
+			if getScope(c).Stat(stat.ID) == nil {
+				return nil, slerrors.Forbidden("One or more stats are not part of scope.")
+			}
+			if stat.Required < 0 {
+				return nil, slerrors.BadRequest("-1 stats are not allowed when creating project requirements.")
+			}
+		}
+
+		project, err := db.Projects(getScope(c).ID).Find(c.Request.Context(), id)
+		if err != nil {
+			return nil, err
+		}
+
+		return db.Projects(getScope(c).ID).AddRequirement(c.Request.Context(), project.ProjectEntry, *requirement)
+	}))
+
+	g.PUT("/:id/requirements/:rid", handler("project", func(c *gin.Context) (interface{}, error) {
+		id, err := reqInt(c, "id")
+		if err != nil {
+			return nil, err
+		}
+		rid, err := reqInt(c, "rid")
+		if err != nil {
+			return nil, err
+		}
+
+		update := &models.ProjectRequirementUpdate{}
+		err = c.BindJSON(update)
+		if err != nil {
+			return nil, slerrors.BadRequest("Invalid JSON input: " + err.Error())
+		}
+
+		if update.Name != nil && *update.Name == "" {
+			return nil, slerrors.BadRequest("Requirement name cannot be empty.")
+		}
+		if update.Status != nil && !update.Status.Valid() {
+			return nil, slerrors.BadRequest("Bad requirement status.")
+		}
+		for _, stat := range update.Stats {
+			if getScope(c).Stat(stat.ID) == nil {
+				return nil, slerrors.Forbidden("One or more stats are not part of scope.")
+			}
+		}
+
+		project, err := db.Projects(getScope(c).ID).Find(c.Request.Context(), id)
+		if err != nil {
+			return nil, err
+		}
+		requirement := project.Requirement(rid)
+		if requirement == nil {
+			return nil, slerrors.NotFound("Project requirement")
+		}
+
+		return db.Projects(getScope(c).ID).UpdateRequirement(c.Request.Context(), project.ProjectEntry, *requirement, *update)
+	}))
+
+	g.DELETE("/:id/requirements/:rid", handler("project", func(c *gin.Context) (interface{}, error) {
+		deleteItems := c.Query("deleteItems") == "true"
+		id, err := reqInt(c, "id")
+		if err != nil {
+			return nil, err
+		}
+		rid, err := reqInt(c, "rid")
+		if err != nil {
+			return nil, err
+		}
+
+		project, err := db.Projects(getScope(c).ID).Find(c.Request.Context(), id)
+		if err != nil {
+			return nil, err
+		}
+		requirement := project.Requirement(rid)
+		if requirement == nil {
+			return nil, slerrors.NotFound("Project requirement")
+		}
+
+		return db.Projects(getScope(c).ID).DeleteRequirement(c.Request.Context(), project.ProjectEntry, *requirement, deleteItems)
+	}))
+
+	g.DELETE("/:id", handler("project", func(c *gin.Context) (interface{}, error) {
+		deleteItems := c.Query("deleteItems") == "true"
+		id, err := reqInt(c, "id")
+		if err != nil {
+			return nil, err
+		}
+
+		project, err := db.Projects(getScope(c).ID).Find(c.Request.Context(), id)
+		if err != nil {
+			return nil, err
+		}
+
+		err = db.Projects(getScope(c).ID).Delete(c.Request.Context(), project.ProjectEntry, deleteItems)
+		if err != nil {
+			return nil, err
+		}
+
+		return project, nil
+	}))
+}

api/scope.go

@@ -0,0 +1,35 @@
+package api
+
+import (
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/auth"
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/database"
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/models"
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/slerrors"
+	"github.com/gin-gonic/gin"
+)
+
+func Scopes(g *gin.RouterGroup, db database.Database) {
+	g.GET("", handler("scopes", func(c *gin.Context) (interface{}, error) {
+		return db.Scopes().ListByUser(c.Request.Context(), auth.UserID(c))
+	}))
+
+	g.GET("/:id", handler("scope", func(c *gin.Context) (interface{}, error) {
+		id, err := reqInt(c, "id")
+		if err != nil {
+			return nil, err
+		}
+
+		scope, err := db.Scopes().Find(c.Request.Context(), id, true)
+		if err != nil {
+			return nil, err
+		}
+		member := scope.Member(auth.UserID(c))
+		if member == nil {
+			return nil, slerrors.NotFound("Scope")
+		}
+		scope.DisplayName = member.Name
+		scope.StatusLabels = models.StatusLabels
+
+		return scope, nil
+	}))
+}

api/stats.go

@@ -0,0 +1,98 @@
+package api
+
+import (
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/database"
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/models"
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/slerrors"
+	"github.com/gin-gonic/gin"
+)
+
+func Stats(g *gin.RouterGroup, db database.Database) {
+	g.Use(scopeIDMiddleware(db))
+
+	g.GET("", handler("stats", func(c *gin.Context) (interface{}, error) {
+		return getScope(c).Stats, nil
+	}))
+
+	g.GET("/:id", handler("stat", func(c *gin.Context) (interface{}, error) {
+		id, err := reqInt(c, "id")
+		if err != nil {
+			return nil, err
+		}
+
+		stat := getScope(c).Stat(id)
+		if stat == nil {
+			return nil, slerrors.NotFound("Stat")
+		}
+
+		return stat, nil
+	}))
+
+	g.POST("", handler("stat", func(c *gin.Context) (interface{}, error) {
+		stat := &models.Stat{}
+		err := c.BindJSON(stat)
+		if err != nil {
+			return nil, slerrors.BadRequest("Invalid JSON input: " + err.Error())
+		}
+
+		if stat.Name == "" {
+			return nil, slerrors.BadRequest("Project name cannot be blank")
+		}
+		if stat.Weight < 0 {
+			return nil, slerrors.BadRequest("Negative weight not allowed")
+		}
+		for key, value := range stat.AllowedAmounts {
+			if value <= 0 {
+				return nil, slerrors.BadRequest("Invalid allowed amount: " + key + "  (0/-1 only allowed when updating to delete them)")
+			}
+		}
+
+		return db.Stats(getScope(c).ID).Create(c.Request.Context(), *stat)
+	}))
+
+	g.PUT("/:id", handler("stat", func(c *gin.Context) (interface{}, error) {
+		id, err := reqInt(c, "id")
+		if err != nil {
+			return nil, err
+		}
+
+		update := &models.StatUpdate{}
+		err = c.BindJSON(update)
+		if err != nil {
+			return nil, slerrors.BadRequest("Invalid JSON input: " + err.Error())
+		}
+
+		stat := getScope(c).Stat(id)
+		if stat == nil {
+			return nil, slerrors.NotFound("Stat")
+		}
+
+		if update.Name != nil && *update.Name == "" {
+			return nil, slerrors.BadRequest("Project name cannot be blank")
+		}
+		if update.Weight != nil && *update.Weight < 0 {
+			return nil, slerrors.BadRequest("Negative weight not allowed")
+		}
+
+		return db.Stats(getScope(c).ID).Update(c.Request.Context(), *stat, *update)
+	}))
+
+	g.DELETE("/:id", handler("stat", func(c *gin.Context) (interface{}, error) {
+		id, err := reqInt(c, "id")
+		if err != nil {
+			return nil, err
+		}
+
+		stat := getScope(c).Stat(id)
+		if stat == nil {
+			return nil, slerrors.NotFound("Stat")
+		}
+
+		err = db.Stats(getScope(c).ID).Delete(c.Request.Context(), *stat)
+		if err != nil {
+			return nil, err
+		}
+
+		return stat, nil
+	}))
+}

cmd/stufflog3-server.go

@@ -0,0 +1,64 @@
+package main
+
+import (
+	"git.aiterp.net/stufflog3/stufflog3-api/api"
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/auth"
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/database/mysql"
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/envvars"
+	"github.com/gin-gonic/gin"
+	"log"
+	"os"
+	"os/signal"
+	"syscall"
+)
+
+func main() {
+	db, err := mysql.Connect(
+		envvars.String("STUFFLOG3_MYSQL_HOST"),
+		envvars.Int("STUFFLOG3_MYSQL_PORT"),
+		envvars.String("STUFFLOG3_MYSQL_USERNAME"),
+		envvars.String("STUFFLOG3_MYSQL_PASSWORD"),
+		envvars.String("STUFFLOG3_MYSQL_SCHEMA"),
+	)
+	if err != nil {
+		log.Println("Failed to open database:", err)
+		os.Exit(1)
+	}
+
+	server := gin.New()
+	if envvars.String("STUFFLOG3_USE_DUMMY_USER") != "" {
+		log.Println("Using dummy UUID")
+		server.Use(auth.DummyMiddleware("c11230be-4912-4313-83b0-410a248b5bd1"))
+	} else {
+		server.Use(auth.TrustingJwtParserMiddleware())
+	}
+
+	api.Scopes(server.Group("/api/scopes"), db)
+	api.Items(server.Group("/api/scope/:scope_id/items"), db)
+	api.Projects(server.Group("/api/scope/:scope_id/projects"), db)
+	api.Stats(server.Group("/api/scope/:scope_id/stats"), db)
+
+	exitSignal := make(chan os.Signal)
+	signal.Notify(exitSignal, os.Interrupt, os.Kill, syscall.SIGTERM)
+
+	errCh := make(chan error)
+	go func() {
+		err := server.Run(":8239")
+		if err != nil {
+			errCh <- err
+		}
+	}()
+
+	select {
+	case sig := <-exitSignal:
+		{
+			log.Println("Received signal", sig)
+			os.Exit(0)
+		}
+	case err := <-errCh:
+		{
+			log.Println("Server run failed:", err)
+			os.Exit(2)
+		}
+	}
+}

frontend/.gitignore

@@ -0,0 +1,8 @@
+.DS_Store
+node_modules
+/build
+/.svelte-kit
+/package
+.env
+.env.*
+!.env.example

frontend/src/app.d.ts

@@ -17,6 +17,7 @@ declare global {
 		// interface Session {}
 		interface Stuff {
 			scope?: Scope
+			scopePath?: string
 		}
 	}
 }

frontend/src/hooks.ts

@@ -1,11 +1,12 @@
 import config from "$lib/config";
+import type { ScopeEntry } from "$lib/models/scope";
 import type { Handle } from "@sveltejs/kit";
 
 export const handle: Handle = async({ event, resolve }) => {
   if (process.env.STUFFLOG3_USE_DUMMY_USER === "true") {
     event.locals.user = {
       id: "c11230be-4912-4313-83b0-410a248b5bd1",
-      name: "Developer",
+      name: "DevMan",
     }
   } else {
     event.locals.user = {id: "", name: "Guest"};
@@ -14,8 +15,8 @@ export const handle: Handle = async({ event, resolve }) => {
   }
 
   if (event.locals.user.id !== "") {
-    const db = await config.database();
-    event.locals.scopes = await db.withUser(event.locals.user.id).scopes().list()
+    const res: {scopes: ScopeEntry[]} = await fetch(`${process.env.STUFFLOG3_API}/api/scopes`).then(r => r.json());
+    event.locals.scopes = res.scopes;
   } else {
     event.locals.scopes = [];
   }

frontend/src/lib/components/frontpage/ScopeLink.svelte

@@ -6,7 +6,7 @@
   export let scope: ScopeEntry
 </script>
 
-<a href="/{scope.id}/">
+<a href="/{scope.id}-{scope.abbreviation.toLocaleLowerCase()}/">
   <CardEntry>
     <EntryName subtitle={scope.abbreviation}>{scope.name}</EntryName>
   </CardEntry>

frontend/src/lib/config.ts

@@ -0,0 +1,3 @@
+const config = {};
+
+export default config;

frontend/src/lib/models/item.ts

@@ -4,12 +4,16 @@ import type { StatProgressEntry } from "./stat";
 
 export default interface Item {
   id: number
+  scopeId: number
+  ownerId: string
+  projectId?: number
+  projectRequirementId?: number
   name: string
   description: string
-  createdTime: Date
-  createdBy: string
-  acquireTime?: Date
+  createdTime: string
+  acquireTime?: string
   scheduledDate?: string
+  
   stats: StatProgressEntry[]
 }
 

frontend/src/lib/models/project.ts

@@ -1,17 +1,17 @@
+import type Item from "./item";
 import type { ScopeEntry } from "./scope";
 import type { StatProgressEntry } from "./stat";
 import type Status from "./status";
 
 export default interface Project extends ProjectEntry {
   description: string
-  author: string
-
-  scope: ScopeEntry
   requirements: Requirement[]
 }
 
 export interface ProjectEntry {
   id: number
+  ownerId: string
+  createdTime: string
   name: string
   status: Status
 }
@@ -23,6 +23,7 @@ export interface Requirement {
   status: Status
 
   stats: StatProgressEntry[]
+  items: Item[]
 }
 
 export interface StandaloneRequirement extends Requirement {

frontend/src/lib/models/scope.ts

@@ -1,22 +1,18 @@
 import type { ProjectEntry } from "./project";
 import type Stat from "./stat";
-
-export default interface Scope extends ScopeEntry {
-  projects: ProjectEntry[]
-  stats: Stat[]
-}
+import type Status from "./status";
 
 export interface ScopeEntry {
   id: number
   name: string
   abbreviation: string
-  displayName: string
 }
 
-export interface ScopeInput {
-  name: string
-  abbreviation: string
+export default interface Scope extends ScopeEntry {
   displayName: string
+  projects: ProjectEntry[]
+  stats: Stat[]
+  statusLabels: Record<Status, string>
 }
 
 export interface ScopeMember {

frontend/src/lib/models/stat.ts

@@ -0,0 +1,20 @@
+export default interface Stat extends StatEntry {
+  description: string
+  allowedAmounts?: Record<string, number>
+}
+
+export interface StatEntry {
+  id: number
+  weight: number
+  name: string
+}
+
+export interface StatProgressEntry extends StatEntry {
+  acquired: number
+  required: number
+}
+
+export interface StatAggregate {
+  acquired: number
+  required: number
+}

frontend/src/lib/utils/slugify.ts

@@ -0,0 +1,13 @@
+export default function sluggify(s: string): string {
+  let out = "";
+
+  for (const c of s.toLocaleLowerCase()) {
+    if (c >= 'a' && c <= 'z') {
+      out += c;
+    } else if (!":'".includes(c)) {
+      out += "-";
+    }
+  }
+
+  return out;
+}

frontend/src/routes/[scope]/__layout.svelte

@@ -2,22 +2,21 @@
   import type { Load } from "@sveltejs/kit/types/internal";
 
   export const load: Load = async({ fetch, params }) => {
-		const res = await fetch(`/${params.scope}.json`);
+    try {
+      const res: {scope: Scope} = await fetch(`/api/scopes/${params.scope.split("-")[0]}`).then(r => r.json());
 
-		if (res.ok) {
-			const data = await res.json();
-
-			return {
-				props: {
-          ...data,
+      return {
+        props: {
+          ...res,
         },
         stuff: {
-          scope: data.scope,
+          scope: res.scope,
+          scopePath: params.scope,
         }
-			};
-		}
+      };
+    } catch(_) {}
 
-		return {fallthrough: true};
+		return {fallthrough: true} as any;
 	}
 
   const STATUS_ORDER = [
@@ -38,6 +37,8 @@
   import MenuCategory from "$lib/components/layout/MenuCategory.svelte";
   import type { ProjectEntry } from "$lib/models/project";
   import MenuItem from "$lib/components/layout/MenuItem.svelte";
+  import {page} from "$app/stores";
+import sluggify from "$lib/utils/slugify";
 
   export let scope: Scope;
 
@@ -56,14 +57,14 @@
   <div class="column side">
     <Header subtitle={scope.name}>{scope.abbreviation}</Header>
     <MenuCategory title="Scope">
-      <MenuItem href="/{scope.id}">Overview</MenuItem>
-      <MenuItem href="/{scope.id}/history">History</MenuItem>
+      <MenuItem href="/{$page.  stuff.scopePath}">Overview</MenuItem>
+      <MenuItem href="/{$page.stuff.scopePath}/history">History</MenuItem>
     </MenuCategory>
     {#each STATUS_ORDER as status (status)}
       {#if projectsByStatus[status].length > 0}
         <MenuCategory status={status}>
           {#each projectsByStatus[status] as project (project.id)}
-            <MenuItem href="/{scope.id}/project/{project.id}" subtitle={
+            <MenuItem href="/{$page.stuff.scopePath}/project/{project.id}-{sluggify(project.name)}" subtitle={
               project.name.includes(": ") ? project.name.split(": ")[0] + ": " : ""
             }>{
               project.name.includes(": ") ? project.name.split(": ").slice(1).join(": ") : project.name

frontend/src/routes/api/[...any]/index.ts

@@ -0,0 +1,30 @@
+import type { RequestHandler } from "@sveltejs/kit";
+
+export const get: RequestHandler = async({ request, params }) => {  
+  const proxyUrl = `${process.env.STUFFLOG3_API}/api/${params.any}`;
+
+  console.log("PRX", proxyUrl);
+  const res = await fetch(proxyUrl, {
+    method: request.method,
+    headers: {
+      ...request.headers,
+    },
+    body: request.body,
+  });
+
+  const result = {
+    status: res.status,
+    body: await res.text(),
+    headers: {},
+  }
+  res.headers.forEach((v, k) => {
+    result.headers[k] = v;
+  })
+ 
+  return result;
+}
+
+export const options = get;
+export const post = get;
+export const put = get;
+export const del = get;

frontend/src/routes/indexdata.json.ts

@@ -0,0 +1,25 @@
+import type { RequestHandler } from "@sveltejs/kit"
+
+import type { StandaloneItem } from "$lib/models/item"
+import type { StandaloneRequirement } from "$lib/models/project"
+import type { ScopeEntry } from "$lib/models/scope"
+import Status from "$lib/models/status"
+import type { StandaloneSprint } from "$lib/models/sprint"
+
+export const get: RequestHandler = async({locals}) => {
+  const scopes: ScopeEntry[] = locals.scopes;
+
+  const items: StandaloneItem[] = []
+  const requirements: StandaloneRequirement[] = []
+  const sprints: StandaloneSprint[] = []
+
+  return {
+    status: 200,
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      scopes, items, requirements, sprints
+    }),
+  }
+}

go.mod

@@ -0,0 +1,11 @@
+module git.aiterp.net/stufflog3/stufflog3-api
+
+go 1.17
+
+require (
+	github.com/gin-gonic/gin v1.7.7
+	github.com/go-sql-driver/mysql v1.6.0
+	github.com/kyleconroy/sqlc v1.13.0
+)
+
+require golang.org/x/sync v0.0.0-20210220032951-036812b2e83c

go.sum

@@ -0,0 +1,275 @@
+github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
+github.com/Masterminds/semver/v3 v3.1.1/go.mod h1:VPu/7SZ7ePZ3QOrcuXROw5FAcLl4a0cBrbBpGY/8hQs=
+github.com/antlr/antlr4/runtime/Go/antlr v0.0.0-20220209173558-ad29539cd2e9/go.mod h1:F7bn7fEU90QkQ3tnmaTx3LTKLEDqnwWODIYppRQ5hnY=
+github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA=
+github.com/cockroachdb/apd v1.1.0/go.mod h1:8Sl8LxpKi29FqWXR16WEFZRNSz3SoPzUzeMeY4+DwBQ=
+github.com/coreos/go-systemd v0.0.0-20190321100706-95778dfbb74e/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
+github.com/coreos/go-systemd v0.0.0-20190719114852-fd7a80b32e1f/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
+github.com/cpuguy83/go-md2man/v2 v2.0.1/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/creack/pty v1.1.7/go.mod h1:lj5s0c3V2DBrqTV7llrYr5NG6My20zk30Fl46Y7DoTY=
+github.com/cznic/golex v0.0.0-20181122101858-9c343928389c/go.mod h1:+bmmJDNmKlhWNG+gwWCkaBoTy39Fs+bzRxVBzoTQbIc=
+github.com/cznic/mathutil v0.0.0-20181122101859-297441e03548/go.mod h1:e6NPNENfs9mPDVNRekM7lKScauxd5kXTr1Mfyig6TDM=
+github.com/cznic/parser v0.0.0-20160622100904-31edd927e5b1/go.mod h1:2B43mz36vGZNZEwkWi8ayRSSUXLfjL8OkbzwW4NcPMM=
+github.com/cznic/sortutil v0.0.0-20181122101858-f5f958428db8/go.mod h1:q2w6Bg5jeox1B+QkJ6Wp/+Vn0G/bo3f1uY7Fn3vivIQ=
+github.com/cznic/strutil v0.0.0-20171016134553-529a34b1c186/go.mod h1:AHHPPPXTw0h6pVabbcbyGRK1DckRn7r/STdZEeIDzZc=
+github.com/cznic/y v0.0.0-20170802143616-045f81c6662a/go.mod h1:1rk5VM7oSnA4vjp+hrLQ3HWHa+Y4yPCa3/CsJrcNnvs=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
+github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
+github.com/gin-gonic/gin v1.7.7 h1:3DoBmSbJbZAWqXJC3SLjAPfutPJJRN1U5pALB7EeTTs=
+github.com/gin-gonic/gin v1.7.7/go.mod h1:axIBovoeJpVj8S3BwE0uPMTeReE4+AfFtqpqaZ1qq1U=
+github.com/go-kit/log v0.1.0/go.mod h1:zbhenjAZHb184qTLMA9ZjW7ThYL0H2mk7Q6pNt4vbaY=
+github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A=
+github.com/go-playground/assert/v2 v2.0.1 h1:MsBgLAaY856+nPRTKrp3/OZK38U/wa0CcBYNjji3q3A=
+github.com/go-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
+github.com/go-playground/locales v0.13.0 h1:HyWk6mgj5qFqCT5fjGBuRArbVDfE4hi8+e8ceBS/t7Q=
+github.com/go-playground/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTMfnGwq/HNwmWNS8=
+github.com/go-playground/universal-translator v0.17.0 h1:icxd5fm+REJzpZx7ZfpaD876Lmtgy7VtROAbHHXk8no=
+github.com/go-playground/universal-translator v0.17.0/go.mod h1:UkSxE5sNxxRwHyU+Scu5vgOQjsIJAF8j9muTVoKLVtA=
+github.com/go-playground/validator/v10 v10.4.1 h1:pH2c5ADXtd66mxoE0Zm9SUhxE20r7aM3F26W0hOn+GE=
+github.com/go-playground/validator/v10 v10.4.1/go.mod h1:nlOn6nFhuKACm19sB/8EGNn9GlaMV7XkbRSipzJ0Ii4=
+github.com/go-sql-driver/mysql v1.3.0/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w=
+github.com/go-sql-driver/mysql v1.6.0 h1:BCTh4TKNUYmOmMUcQ3IipzF5prigylS7XXjEkfCHuOE=
+github.com/go-sql-driver/mysql v1.6.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=
+github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
+github.com/gofrs/uuid v4.0.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM=
+github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
+github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
+github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
+github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
+github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
+github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
+github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
+github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
+github.com/golang/protobuf v1.5.2 h1:ROPKBNFfQgOUMifHyP+KYbvpjbdoFNs+aK7DXlji0Tw=
+github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
+github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.7 h1:81/ik6ipDQS2aGcBfIN5dHDB36BwrStyeAQquSYCV4o=
+github.com/google/go-cmp v0.5.7/go.mod h1:n+brtR0CgQNWTVd5ZUFpTBC8YFBDLK/h/bpaJ8/DtOE=
+github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
+github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
+github.com/jackc/chunkreader v1.0.0/go.mod h1:RT6O25fNZIuasFJRyZ4R/Y2BbhasbmZXF9QQ7T3kePo=
+github.com/jackc/chunkreader/v2 v2.0.0/go.mod h1:odVSm741yZoC3dpHEUXIqA9tQRhFrgOHwnPIn9lDKlk=
+github.com/jackc/chunkreader/v2 v2.0.1/go.mod h1:odVSm741yZoC3dpHEUXIqA9tQRhFrgOHwnPIn9lDKlk=
+github.com/jackc/pgconn v0.0.0-20190420214824-7e0022ef6ba3/go.mod h1:jkELnwuX+w9qN5YIfX0fl88Ehu4XC3keFuOJJk9pcnA=
+github.com/jackc/pgconn v0.0.0-20190824142844-760dd75542eb/go.mod h1:lLjNuW/+OfW9/pnVKPazfWOgNfH2aPem8YQ7ilXGvJE=
+github.com/jackc/pgconn v0.0.0-20190831204454-2fabfa3c18b7/go.mod h1:ZJKsE/KZfsUgOEh9hBm+xYTstcNHg7UPMVJqRfQxq4s=
+github.com/jackc/pgconn v1.8.0/go.mod h1:1C2Pb36bGIP9QHGBYCjnyhqu7Rv3sGshaQUvmfGIB/o=
+github.com/jackc/pgconn v1.9.0/go.mod h1:YctiPyvzfU11JFxoXokUOOKQXQmDMoJL9vJzHH8/2JY=
+github.com/jackc/pgconn v1.9.1-0.20210724152538-d89c8390a530/go.mod h1:4z2w8XhRbP1hYxkpTuBjTS3ne3J48K83+u0zoyvg2pI=
+github.com/jackc/pgconn v1.11.0/go.mod h1:4z2w8XhRbP1hYxkpTuBjTS3ne3J48K83+u0zoyvg2pI=
+github.com/jackc/pgio v1.0.0/go.mod h1:oP+2QK2wFfUWgr+gxjoBH9KGBb31Eio69xUb0w5bYf8=
+github.com/jackc/pgmock v0.0.0-20190831213851-13a1b77aafa2/go.mod h1:fGZlG77KXmcq05nJLRkk0+p82V8B8Dw8KN2/V9c/OAE=
+github.com/jackc/pgmock v0.0.0-20201204152224-4fe30f7445fd/go.mod h1:hrBW0Enj2AZTNpt/7Y5rr2xe/9Mn757Wtb2xeBzPv2c=
+github.com/jackc/pgmock v0.0.0-20210724152146-4ad1a8207f65/go.mod h1:5R2h2EEX+qri8jOWMbJCtaPWkrrNc7OHwsp2TCqp7ak=
+github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
+github.com/jackc/pgproto3 v1.1.0/go.mod h1:eR5FA3leWg7p9aeAqi37XOTgTIbkABlvcPB3E5rlc78=
+github.com/jackc/pgproto3/v2 v2.0.0-alpha1.0.20190420180111-c116219b62db/go.mod h1:bhq50y+xrl9n5mRYyCBFKkpRVTLYJVWeCc+mEAI3yXA=
+github.com/jackc/pgproto3/v2 v2.0.0-alpha1.0.20190609003834-432c2951c711/go.mod h1:uH0AWtUmuShn0bcesswc4aBTWGvw0cAxIJp+6OB//Wg=
+github.com/jackc/pgproto3/v2 v2.0.0-rc3/go.mod h1:ryONWYqW6dqSg1Lw6vXNMXoBJhpzvWKnT95C46ckYeM=
+github.com/jackc/pgproto3/v2 v2.0.0-rc3.0.20190831210041-4c03ce451f29/go.mod h1:ryONWYqW6dqSg1Lw6vXNMXoBJhpzvWKnT95C46ckYeM=
+github.com/jackc/pgproto3/v2 v2.0.6/go.mod h1:WfJCnwN3HIg9Ish/j3sgWXnAfK8A9Y0bwXYU5xKaEdA=
+github.com/jackc/pgproto3/v2 v2.1.1/go.mod h1:WfJCnwN3HIg9Ish/j3sgWXnAfK8A9Y0bwXYU5xKaEdA=
+github.com/jackc/pgproto3/v2 v2.2.0/go.mod h1:WfJCnwN3HIg9Ish/j3sgWXnAfK8A9Y0bwXYU5xKaEdA=
+github.com/jackc/pgservicefile v0.0.0-20200714003250-2b9c44734f2b/go.mod h1:vsD4gTJCa9TptPL8sPkXrLZ+hDuNrZCnj29CQpr4X1E=
+github.com/jackc/pgtype v0.0.0-20190421001408-4ed0de4755e0/go.mod h1:hdSHsc1V01CGwFsrv11mJRHWJ6aifDLfdV3aVjFF0zg=
+github.com/jackc/pgtype v0.0.0-20190824184912-ab885b375b90/go.mod h1:KcahbBH1nCMSo2DXpzsoWOAfFkdEtEJpPbVLq8eE+mc=
+github.com/jackc/pgtype v0.0.0-20190828014616-a8802b16cc59/go.mod h1:MWlu30kVJrUS8lot6TQqcg7mtthZ9T0EoIBFiJcmcyw=
+github.com/jackc/pgtype v1.8.1-0.20210724151600-32e20a603178/go.mod h1:C516IlIV9NKqfsMCXTdChteoXmwgUceqaLfjg2e3NlM=
+github.com/jackc/pgtype v1.10.0/go.mod h1:LUMuVrfsFfdKGLw+AFFVv6KtHOFMwRgDDzBt76IqCA4=
+github.com/jackc/pgx/v4 v4.0.0-20190420224344-cc3461e65d96/go.mod h1:mdxmSJJuR08CZQyj1PVQBHy9XOp5p8/SHH6a0psbY9Y=
+github.com/jackc/pgx/v4 v4.0.0-20190421002000-1b8f0016e912/go.mod h1:no/Y67Jkk/9WuGR0JG/JseM9irFbnEPbuWV2EELPNuM=
+github.com/jackc/pgx/v4 v4.0.0-pre1.0.20190824185557-6972a5742186/go.mod h1:X+GQnOEnf1dqHGpw7JmHqHc1NxDoalibchSk9/RWuDc=
+github.com/jackc/pgx/v4 v4.12.1-0.20210724153913-640aa07df17c/go.mod h1:1QD0+tgSXP7iUjYm9C1NxKhny7lq6ee99u/z+IHFcgs=
+github.com/jackc/pgx/v4 v4.15.0/go.mod h1:D/zyOyXiaM1TmVWnOM18p0xdDtdakRBa0RsVGI3U3bw=
+github.com/jackc/puddle v0.0.0-20190413234325-e4ced69a3a2b/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk=
+github.com/jackc/puddle v0.0.0-20190608224051-11cab39313c9/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk=
+github.com/jackc/puddle v1.1.3/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk=
+github.com/jackc/puddle v1.2.1/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk=
+github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
+github.com/json-iterator/go v1.1.9 h1:9yzud/Ht36ygwatGx56VwCZtlI/2AD15T1X2sjSuGns=
+github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
+github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
+github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/konsorten/go-windows-terminal-sequences v1.0.2/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pretty v0.2.1 h1:Fmg33tUaq4/8ym9TJN1x7sLJnHVwhP33CNkpYV/7rwI=
+github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/pty v1.1.8/go.mod h1:O1sed60cT9XZ5uDucP5qwvh+TE3NnUj51EiZO/lmSfw=
+github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/kyleconroy/sqlc v1.13.0 h1:fhfOZbfuF7ELo5uMB8XkgZJRTnc1YQYtzhyLgp7PzFM=
+github.com/kyleconroy/sqlc v1.13.0/go.mod h1:vO++DmIYZfpVDnR8sgiYkjGB/22E8R7h66fykOIzhI8=
+github.com/leodido/go-urn v1.2.0 h1:hpXL4XnriNwQ/ABnpepYM/1vCLWNDfUNts8dX3xTG6Y=
+github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII=
+github.com/lib/pq v1.0.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
+github.com/lib/pq v1.1.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
+github.com/lib/pq v1.2.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
+github.com/lib/pq v1.10.2/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
+github.com/lib/pq v1.10.4/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
+github.com/mattn/go-colorable v0.1.1/go.mod h1:FuOcm+DKB9mbwrcAfNl7/TZVBZ6rcnceauSikq3lYCQ=
+github.com/mattn/go-colorable v0.1.6/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
+github.com/mattn/go-isatty v0.0.5/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
+github.com/mattn/go-isatty v0.0.7/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
+github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY=
+github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
+github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 h1:ZqeYNhU3OHLH3mGKHDcjJRFFRrJa6eAM5H+CtDdOsPc=
+github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742 h1:Esafd1046DLDQ0W1YjYsBW+p8U2u7vzgW2SQVmlNazg=
+github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
+github.com/pganalyze/pg_query_go/v2 v2.1.0/go.mod h1:XAxmVqz1tEGqizcQ3YSdN90vCOHBWjJi8URL1er5+cA=
+github.com/pingcap/check v0.0.0-20190102082844-67f458068fc8/go.mod h1:B1+S9LNcuMyLH/4HMTViQOJevkGiik3wW2AN9zb2fNQ=
+github.com/pingcap/errors v0.11.0/go.mod h1:Oi8TUi2kEtXXLMJk9l1cGmz20kV3TaQ0usTwv5KuLY8=
+github.com/pingcap/errors v0.11.5-0.20210425183316-da1aaba5fb63/go.mod h1:X2r9ueLEUZgtx2cIogM0v4Zj5uvvzhuuiu7Pn8HzMPg=
+github.com/pingcap/log v0.0.0-20210625125904-98ed8e2eb1c7/go.mod h1:8AanEdAHATuRurdGxZXBz0At+9avep+ub7U1AGYLIMM=
+github.com/pingcap/log v0.0.0-20210906054005-afc726e70354/go.mod h1:DWQW5jICDR7UJh4HtxXSM20Churx4CQL0fwL/SoOSA4=
+github.com/pingcap/parser v0.0.0-20210914110036-002913dd28ec/go.mod h1:+xcMiiZzdIktT/Nqdfm81dkECJ2EPuoAYywd57py4Pk=
+github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
+github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
+github.com/rs/xid v1.2.1/go.mod h1:+uKXf+4Djp6Md1KODXJxgGQPKngRmWyn10oCKFzNHOQ=
+github.com/rs/zerolog v1.13.0/go.mod h1:YbFCdg8HfsridGWAh22vktObvhZbQsZXe4/zB0OKkWU=
+github.com/rs/zerolog v1.15.0/go.mod h1:xYTKnLHcpfU2225ny5qZjxnj9NvkumZYjJHlAThCjNc=
+github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+github.com/satori/go.uuid v1.2.0/go.mod h1:dA0hQrYB0VpLJoorglMZABFdXlWrHn1NEOzdhQKdks0=
+github.com/shopspring/decimal v0.0.0-20180709203117-cd690d0c9e24/go.mod h1:M+9NzErvs504Cn4c5DxATwIqPbtswREoFCre64PpcG4=
+github.com/shopspring/decimal v1.2.0/go.mod h1:DKyhrW/HYNuLGql+MJL6WCR6knT2jwCFRcu2hWCYk4o=
+github.com/sirupsen/logrus v1.4.1/go.mod h1:ni0Sbl8bgC9z8RoU9G6nDWqqs/fq4eDPysMBDgk/93Q=
+github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
+github.com/spf13/cobra v1.4.0/go.mod h1:Wo4iy3BUC+X2Fybo0PDqwJIv3dNRiZLHQymsfxlB84g=
+github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.2.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
+github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/ugorji/go v1.1.7 h1:/68gy2h+1mWMrwZFeD1kQialdSzAb432dtpeJ42ovdo=
+github.com/ugorji/go v1.1.7/go.mod h1:kZn38zHttfInRq0xu/PH0az30d+z6vm202qpg1oXVMw=
+github.com/ugorji/go/codec v1.1.7 h1:2SvQaVZ1ouYrrKKwoSk2pzd4A9evlKJb9oTL+OaLUSs=
+github.com/ugorji/go/codec v1.1.7/go.mod h1:Ax+UKWsSmolVDwsd+7N3ZtXu+yMGCf907BLYF3GoBXY=
+github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
+github.com/zenazn/goji v0.9.0/go.mod h1:7S9M489iMyHBNxwZnk9/EHS098H4/F6TATF2mIxtB1Q=
+go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
+go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
+go.uber.org/atomic v1.5.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ=
+go.uber.org/atomic v1.6.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ=
+go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
+go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
+go.uber.org/goleak v1.1.10/go.mod h1:8a7PlsEVH3e/a/GLqe5IIrQx6GzcnRmZEufDUTk4A7A=
+go.uber.org/goleak v1.1.11-0.20210813005559-691160354723/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ=
+go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
+go.uber.org/multierr v1.3.0/go.mod h1:VgVr7evmIr6uPjLBxg28wmKNXyqE9akIJ5XnfpiKl+4=
+go.uber.org/multierr v1.5.0/go.mod h1:FeouvMocqHpRaaGuG9EjoKcStLC43Zu/fmqdUMPcKYU=
+go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU=
+go.uber.org/multierr v1.7.0/go.mod h1:7EAYxJLBy9rStEaz58O2t4Uvip6FSURkq8/ppBp95ak=
+go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee/go.mod h1:vJERXedbb3MVM5f9Ejo0C68/HhF8uaILCdgjnY+goOA=
+go.uber.org/zap v1.9.1/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
+go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
+go.uber.org/zap v1.13.0/go.mod h1:zwrFLgMcdUuIBviXEYEH1YKNaOBnKXsx2IPda5bBwHM=
+go.uber.org/zap v1.18.1/go.mod h1:xg/QME4nWcxGxrpdeYfq7UvYrLh66cuVKdrbD1XF/NI=
+go.uber.org/zap v1.19.0/go.mod h1:xg/QME4nWcxGxrpdeYfq7UvYrLh66cuVKdrbD1XF/NI=
+go.uber.org/zap v1.19.1/go.mod h1:j3DNczoxDZroyBnOT1L/Q79cfUMGZxlv/9dzN7SM1rI=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20190411191339-88737f569e3a/go.mod h1:WFFai1msRO1wXaEeE5yQxYXgSfI8pQAWXbQop6sCtWE=
+golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20190820162420-60c769a6c586/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20201203163018-be400aefbc4c/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
+golang.org/x/crypto v0.0.0-20210616213533-5ff15b29337e/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/crypto v0.0.0-20210817164053-32db794688a5 h1:HWj/xjIHfjYU5nVXpTM0s39J9CbLn7Cc5a7IC5rwsMQ=
+golang.org/x/crypto v0.0.0-20210817164053-32db794688a5/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=
+golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
+golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190813141303-74dc4d7220e7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20210220032951-036812b2e83c h1:5KslGYwFpkhGh+Q16bwMP3cOontH8FOep7tGV86Y7SQ=
+golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190403152447-81d4e9dc473e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1 h1:SrN+KX8Art/Sf4HNj6Zcz06G7VEz+7w9tdXTPOZ7+l4=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190425163242-31fd60d6bfdc/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
+golang.org/x/tools v0.0.0-20190823170909-c4a336ef6a2f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191108193012-7d206e10da11/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20200103221440-774c71fcf114/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
+golang.org/x/xerrors v0.0.0-20190410155217-1f06c39b4373/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20190513163551-3ee3066db522/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
+google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
+google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
+google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
+google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
+google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
+google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
+google.golang.org/protobuf v1.28.0 h1:w43yiav+6bVFTBQFZX0r7ipe9JQ1QsbMgHwbBziscLw=
+google.golang.org/protobuf v1.28.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
+gopkg.in/inconshreveable/log15.v2 v2.0.0-20180818164646-67afb5ed74ec/go.mod h1:aPpfJ7XW+gOuirDoZ8gHhLh3kZ1B08FtV2bbmy7Jv3s=
+gopkg.in/natefinch/lumberjack.v2 v2.0.0/go.mod h1:l0ndWWf7gzL7RNwBG7wST/UCcT4T24xpD6X8LsfU/+k=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
+gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b h1:h8qDotaEPuJATrMmW04NCwg7v22aHH28wwpauUhK9Oo=
+gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=

internal/auth/auth.go

@@ -0,0 +1,71 @@
+package auth
+
+import (
+	"context"
+	"encoding/base64"
+	"encoding/json"
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/slerrors"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strings"
+)
+
+var contextKey = struct{}{}
+
+func UserID(ctx context.Context) string {
+	if c, ok := ctx.(*gin.Context); ok {
+		return UserID(c.Request.Context())
+	}
+
+	return ctx.Value(&contextKey).(string)
+}
+
+func DummyMiddleware(uuid string) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		c.Request = c.Request.WithContext(
+			context.WithValue(c.Request.Context(), &contextKey, uuid),
+		)
+	}
+}
+
+func abortRequest(c *gin.Context) {
+	c.AbortWithStatusJSON(http.StatusUnauthorized, slerrors.ErrorResponse{
+		Code:    http.StatusUnauthorized,
+		Message: "You're not supposed to be here!",
+	})
+}
+
+// TrustingJwtParserMiddleware is meant to be put behind an AWS API gateway that has already
+// verified this token.
+func TrustingJwtParserMiddleware() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		auth := c.GetHeader("Authorization")
+		split := strings.Split(auth, ".")
+
+		if len(split) >= 3 {
+			data, err := base64.RawStdEncoding.DecodeString(split[1])
+			if err != nil {
+				abortRequest(c)
+				return
+			}
+
+			fields := make(map[string]interface{})
+			err = json.Unmarshal(data, &fields)
+			if err != nil {
+				abortRequest(c)
+				return
+			}
+
+			if sub, ok := fields["sub"].(string); ok {
+				c.Request = c.Request.WithContext(
+					context.WithValue(c.Request.Context(), &contextKey, sub),
+				)
+			} else {
+				abortRequest(c)
+				return
+			}
+		} else {
+			abortRequest(c)
+		}
+	}
+}

internal/database/database.go

@@ -0,0 +1,64 @@
+package database
+
+import (
+	"context"
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/models"
+	"time"
+)
+
+type Database interface {
+	Scopes() ScopeRepository
+	Stats(scopeID int) StatRepository
+	Items(scopeID int) ItemRepository
+	Projects(scopeID int) ProjectRepository
+	ItemsMultiScope(scopeIDs []int) ItemMultiScopeRepository
+}
+
+type ScopeRepository interface {
+	Find(ctx context.Context, id int, full bool) (*models.Scope, error)
+	List(ctx context.Context) ([]models.ScopeEntry, error)
+	ListByUser(ctx context.Context, userID string) ([]models.ScopeEntry, error)
+	Create(ctx context.Context, scope models.ScopeEntry, owner models.ScopeMember) (*models.Scope, error)
+	Update(ctx context.Context, scope models.ScopeEntry) error
+	Delete(ctx context.Context, scope models.Scope) error
+	UpdateMember(ctx context.Context, scope models.Scope, member models.ScopeMember) (*models.Scope, error)
+	DeleteMember(ctx context.Context, scope models.Scope, userID string) (*models.Scope, error)
+}
+
+type StatRepository interface {
+	Find(ctx context.Context, id int) (*models.Stat, error)
+	List(ctx context.Context) ([]models.Stat, error)
+	Create(ctx context.Context, stat models.Stat) (*models.Stat, error)
+	Update(ctx context.Context, stat models.Stat, update models.StatUpdate) (*models.Stat, error)
+	Delete(ctx context.Context, stat models.Stat) error
+}
+
+type ItemRepository interface {
+	Find(ctx context.Context, id int) (*models.Item, error)
+	ListCreated(ctx context.Context, from, to time.Time) ([]models.Item, error)
+	ListAcquired(ctx context.Context, from, to time.Time) ([]models.Item, error)
+	ListScheduled(ctx context.Context, from, to models.Date) ([]models.Item, error)
+	ListLoose(ctx context.Context, from, to time.Time) ([]models.Item, error)
+	Create(ctx context.Context, item models.Item) (*models.Item, error)
+	Update(ctx context.Context, item models.Item, update models.ItemUpdate) (*models.Item, error)
+	Delete(ctx context.Context, item models.Item) error
+}
+
+type ItemMultiScopeRepository interface {
+	ListCreated(ctx context.Context, from, to time.Time) ([]models.Item, error)
+	ListAcquired(ctx context.Context, from, to time.Time) ([]models.Item, error)
+	ListScheduled(ctx context.Context, from, to models.Date) ([]models.Item, error)
+	ListLoose(ctx context.Context, from, to time.Time) ([]models.Item, error)
+}
+
+type ProjectRepository interface {
+	Find(ctx context.Context, id int) (*models.Project, error)
+	List(ctx context.Context) ([]models.ProjectEntry, error)
+	Create(ctx context.Context, project models.Project) (*models.Project, error)
+	Update(ctx context.Context, project models.Project, update models.ProjectUpdate) (*models.Project, error)
+	Delete(ctx context.Context, project models.ProjectEntry, deleteItems bool) error
+
+	AddRequirement(ctx context.Context, project models.ProjectEntry, requirement models.ProjectRequirement) (*models.Project, error)
+	UpdateRequirement(ctx context.Context, project models.ProjectEntry, requirement models.ProjectRequirement, update models.ProjectRequirementUpdate) (*models.Project, error)
+	DeleteRequirement(ctx context.Context, project models.ProjectEntry, requirement models.ProjectRequirement, deleteItems bool) (*models.Project, error)
+}

internal/database/mysql/database.go

@@ -0,0 +1,69 @@
+package mysql
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/database"
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/database/mysql/mysqlcore"
+	"time"
+
+	_ "github.com/go-sql-driver/mysql"
+)
+
+type Database struct {
+	db *sql.DB
+	q  *mysqlcore.Queries
+}
+
+func (d *Database) Scopes() database.ScopeRepository {
+	return &scopeRepository{db: d.db, q: d.q}
+}
+
+func (d *Database) Stats(scopeID int) database.StatRepository {
+	return &statsRepository{
+		db: d.db, q: d.q,
+		scopeID: scopeID,
+	}
+}
+
+func (d *Database) Items(scopeID int) database.ItemRepository {
+	return &itemRepository{db: d.db, q: d.q, scopeID: scopeID}
+}
+
+func (d *Database) Projects(scopeID int) database.ProjectRepository {
+	return &projectRepository{
+		db: d.db, q: d.q, scopeID: scopeID,
+		items: &itemRepository{db: d.db, q: d.q, scopeID: scopeID},
+	}
+}
+
+func (d *Database) ItemsMultiScope(scopeIDs []int) database.ItemMultiScopeRepository {
+	//TODO implement me
+	panic("implement me")
+}
+
+func Connect(host string, port int, username, password, database string) (*Database, error) {
+	db, err := sql.Open("mysql", fmt.Sprintf(
+		"%s:%s@(%s:%d)/%s?parseTime=true", username, password, host, port, database,
+	))
+	if err != nil {
+		return nil, err
+	}
+
+	db.SetMaxOpenConns(10)
+	db.SetMaxIdleConns(10)
+	db.SetConnMaxIdleTime(time.Minute)
+
+	err = db.Ping()
+	if err != nil {
+		return nil, err
+	}
+
+	q, err := mysqlcore.Prepare(context.Background(), db)
+	if err != nil {
+		return nil, err
+	}
+
+	return &Database{db: db, q: q}, nil
+}

internal/database/mysql/items.go

@@ -0,0 +1,374 @@
+package mysql
+
+import (
+	"context"
+	"database/sql"
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/database/mysql/mysqlcore"
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/models"
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/slerrors"
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/sqltypes"
+	"strings"
+	"time"
+)
+
+type itemRepository struct {
+	db      *sql.DB
+	q       *mysqlcore.Queries
+	scopeID int
+}
+
+func (r *itemRepository) Find(ctx context.Context, id int) (*models.Item, error) {
+	res, err := r.q.GetItem(ctx, id)
+	if err != nil {
+		if err == sql.ErrNoRows {
+			return nil, slerrors.NotFound("Item")
+		}
+		return nil, err
+	}
+	if res.ScopeID != r.scopeID {
+		return nil, slerrors.NotFound("Item")
+	}
+
+	item := r.resToItem(mysqlcore.ListItemsAcquiredBetweenRow(res))
+
+	stats, _ := r.q.ListItemStatProgress(ctx, id)
+	for _, stat := range stats {
+		item.Stats = append(item.Stats, models.StatProgressEntry{
+			StatEntry: models.StatEntry{
+				ID:     int(stat.ID.Int32),
+				Name:   stat.Name.String,
+				Weight: stat.Weight,
+			},
+			Acquired: stat.Acquired,
+			Required: stat.Required,
+		})
+	}
+
+	return &item, nil
+}
+
+func (r *itemRepository) ListCreated(ctx context.Context, from, to time.Time) ([]models.Item, error) {
+	rows, err := r.q.ListItemsCreatedBetween(ctx, mysqlcore.ListItemsCreatedBetweenParams{
+		CreatedTime:   from,
+		CreatedTime_2: to,
+		ScopeID:       r.scopeID,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	items := make([]models.Item, 0, len(rows))
+	for _, row := range rows {
+		items = append(items, r.resToItem(mysqlcore.ListItemsAcquiredBetweenRow(row)))
+	}
+
+	err = r.fillStats(ctx, items)
+	if err != nil {
+		return nil, err
+	}
+
+	return items, nil
+}
+
+func (r *itemRepository) ListAcquired(ctx context.Context, from, to time.Time) ([]models.Item, error) {
+	rows, err := r.q.ListItemsAcquiredBetween(ctx, mysqlcore.ListItemsAcquiredBetweenParams{
+		AcquiredTime:   sql.NullTime{Valid: true, Time: from},
+		AcquiredTime_2: sql.NullTime{Valid: true, Time: to},
+		ScopeID:        r.scopeID,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	items := make([]models.Item, 0, len(rows))
+	for _, row := range rows {
+		items = append(items, r.resToItem(row))
+	}
+
+	err = r.fillStats(ctx, items)
+	if err != nil {
+		return nil, err
+	}
+
+	return items, nil
+}
+
+func (r *itemRepository) ListScheduled(ctx context.Context, from, to models.Date) ([]models.Item, error) {
+	rows, err := r.q.ListItemsScheduledBetween(ctx, mysqlcore.ListItemsScheduledBetweenParams{
+		ScheduledDate:   sqltypes.NullDate{Valid: true, Date: from},
+		ScheduledDate_2: sqltypes.NullDate{Valid: true, Date: to},
+		ScopeID:         r.scopeID,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	items := make([]models.Item, 0, len(rows))
+	for _, row := range rows {
+		items = append(items, r.resToItem(mysqlcore.ListItemsAcquiredBetweenRow(row)))
+	}
+
+	err = r.fillStats(ctx, items)
+	if err != nil {
+		return nil, err
+	}
+
+	return items, nil
+}
+
+func (r *itemRepository) ListLoose(ctx context.Context, from, to time.Time) ([]models.Item, error) {
+	rows, err := r.q.ListItemsLooseBetween(ctx, mysqlcore.ListItemsLooseBetweenParams{
+		CreatedTime:   from,
+		CreatedTime_2: to,
+		ScopeID:       r.scopeID,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	items := make([]models.Item, 0, len(rows))
+	for _, row := range rows {
+		items = append(items, r.resToItem(mysqlcore.ListItemsAcquiredBetweenRow(row)))
+	}
+
+	err = r.fillStats(ctx, items)
+	if err != nil {
+		return nil, err
+	}
+
+	return items, nil
+}
+
+func (r *itemRepository) Create(ctx context.Context, item models.Item) (*models.Item, error) {
+	item.Stats = append(item.Stats[:0:0], item.Stats...)
+
+	tx, err := r.db.BeginTx(ctx, nil)
+	if err != nil {
+		return nil, err
+	}
+	defer tx.Rollback()
+	q := r.q.WithTx(tx)
+
+	if item.ProjectRequirementID != nil {
+		pr, err := q.GetProjectRequirement(ctx, *item.ProjectRequirementID)
+		if err != nil || pr.ScopeID != r.scopeID {
+			return nil, slerrors.NotFound("Project requirement")
+		}
+	}
+
+	prID, acqTime, schDate := r.generateNullables(item)
+
+	res, err := q.InsertItem(ctx, mysqlcore.InsertItemParams{
+		ScopeID:              r.scopeID,
+		ProjectRequirementID: prID,
+		Name:                 item.Name,
+		Description:          item.Description,
+		CreatedTime:          time.Now(),
+		CreatedUserID:        item.OwnerID,
+		AcquiredTime:         acqTime,
+		ScheduledDate:        schDate,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	id, err := res.LastInsertId()
+	if err != nil {
+		return nil, err
+	}
+
+	for _, stat := range item.Stats {
+		err = q.ReplaceItemStatProgress(ctx, mysqlcore.ReplaceItemStatProgressParams{
+			ItemID:   int(id),
+			StatID:   stat.ID,
+			Acquired: stat.Acquired,
+			Required: stat.Required,
+		})
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	err = tx.Commit()
+	if err != nil {
+		return nil, err
+	}
+
+	return r.Find(ctx, int(id))
+}
+
+func (r *itemRepository) generateNullables(item models.Item) (prID sql.NullInt32, acqTime sql.NullTime, schDate sqltypes.NullDate) {
+	if item.ProjectRequirementID != nil {
+		prID.Valid = true
+		prID.Int32 = int32(*item.ProjectRequirementID)
+	}
+	if item.AcquiredTime != nil {
+		acqTime.Valid = true
+		acqTime.Time = *item.AcquiredTime
+	}
+	if item.ScheduledDate != nil {
+		schDate.Valid = true
+		schDate.Date = *item.ScheduledDate
+	}
+
+	return
+}
+
+func (r *itemRepository) Update(ctx context.Context, item models.Item, update models.ItemUpdate) (*models.Item, error) {
+	tx, err := r.db.BeginTx(ctx, nil)
+	if err != nil {
+		return nil, err
+	}
+	defer tx.Rollback()
+
+	q := r.q.WithTx(tx)
+
+	if update.ProjectRequirementID != nil {
+		pr, err := q.GetProjectRequirement(ctx, *update.ProjectRequirementID)
+		if err != nil || pr.ScopeID != r.scopeID {
+			return nil, slerrors.NotFound("Project requirement")
+		}
+	}
+
+	item.ApplyUpdate(update)
+
+	prID, acqTime, schDate := r.generateNullables(item)
+
+	err = q.UpdateItem(ctx, mysqlcore.UpdateItemParams{
+		ID: item.ID,
+
+		ProjectRequirementID: prID,
+		Name:                 item.Name,
+		Description:          item.Description,
+		AcquiredTime:         acqTime,
+		ScheduledDate:        schDate,
+		CreatedUserID:        item.OwnerID,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	for _, stat := range update.Stats {
+		if stat.Acquired == 0 && stat.Required == 0 {
+			err = q.DeleteItemStatProgress(ctx, mysqlcore.DeleteItemStatProgressParams{
+				ItemID: item.ID,
+				StatID: stat.ID,
+			})
+		} else {
+			err = q.ReplaceItemStatProgress(ctx, mysqlcore.ReplaceItemStatProgressParams{
+				ItemID:   item.ID,
+				StatID:   stat.ID,
+				Acquired: stat.Acquired,
+				Required: stat.Required,
+			})
+		}
+
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	err = tx.Commit()
+	if err != nil {
+		return nil, err
+	}
+
+	return r.Find(ctx, item.ID)
+}
+
+func (r *itemRepository) Delete(ctx context.Context, item models.Item) error {
+	tx, err := r.db.BeginTx(ctx, nil)
+	if err != nil {
+		return err
+	}
+	defer tx.Rollback()
+	q := r.q.WithTx(tx)
+
+	err = q.DeleteItem(ctx, item.ID)
+	if err != nil {
+		return err
+	}
+	err = q.ClearItemStatProgress(ctx, item.ID)
+	if err != nil {
+		return err
+	}
+
+	return tx.Commit()
+}
+
+func (r *itemRepository) resToItem(res mysqlcore.ListItemsAcquiredBetweenRow) models.Item {
+	item := models.Item{
+		ID:          res.ID,
+		ScopeID:     res.ScopeID,
+		OwnerID:     res.CreatedUserID,
+		Name:        res.Name,
+		Description: res.Description,
+		CreatedTime: res.CreatedTime.UTC(),
+	}
+	if res.ProjectRequirementID.Valid {
+		projectRequirementID := int(res.ProjectRequirementID.Int32)
+		projectID := int(res.ProjectID.Int32)
+		item.ProjectRequirementID = &projectRequirementID
+		item.ProjectID = &projectID
+	}
+	if res.ScheduledDate.Valid {
+		item.ScheduledDate = &res.ScheduledDate.Date
+	}
+	if res.AcquiredTime.Valid {
+		item.AcquiredTime = &res.AcquiredTime.Time
+	}
+
+	return item
+}
+
+func (r *itemRepository) fillStats(ctx context.Context, items []models.Item) error {
+	if len(items) == 0 {
+		return nil
+	}
+
+	ids := make([]interface{}, 0, len(items))
+	for _, item := range items {
+		ids = append(ids, item.ID)
+	}
+	query := `
+		SELECT isp.item_id, isp.required, isp.acquired, s.id, s.name, s.weight FROM item_stat_progress isp
+		LEFT JOIN stat s ON s.id = isp.stat_id
+		WHERE item_id IN (?` + strings.Repeat(",?", len(ids)-1) + `);
+	`
+
+	rows, err := r.db.QueryContext(ctx, query, ids...)
+	if err != nil {
+		if err == sql.ErrNoRows {
+			return nil
+		}
+
+		return err
+	}
+
+	for rows.Next() {
+		var itemID, required, acquired, statID int
+		var statName string
+		var statWeight float64
+
+		err = rows.Scan(&itemID, &required, &acquired, &statID, &statName, &statWeight)
+		if err != nil {
+			return err
+		}
+
+		for i := range items {
+			if items[i].ID == itemID {
+				items[i].Stats = append(items[i].Stats, models.StatProgressEntry{
+					StatEntry: models.StatEntry{
+						ID:     statID,
+						Name:   statName,
+						Weight: statWeight,
+					},
+					Acquired: acquired,
+					Required: required,
+				})
+			}
+		}
+	}
+
+	return nil
+}

internal/database/mysql/mysqlcore/db.go

@@ -0,0 +1,628 @@
+// Code generated by sqlc. DO NOT EDIT.
+// versions:
+//   sqlc v1.13.0
+
+package mysqlcore
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+)
+
+type DBTX interface {
+	ExecContext(context.Context, string, ...interface{}) (sql.Result, error)
+	PrepareContext(context.Context, string) (*sql.Stmt, error)
+	QueryContext(context.Context, string, ...interface{}) (*sql.Rows, error)
+	QueryRowContext(context.Context, string, ...interface{}) *sql.Row
+}
+
+func New(db DBTX) *Queries {
+	return &Queries{db: db}
+}
+
+func Prepare(ctx context.Context, db DBTX) (*Queries, error) {
+	q := Queries{db: db}
+	var err error
+	if q.cLearItemStatProgressByStatStmt, err = db.PrepareContext(ctx, cLearItemStatProgressByStat); err != nil {
+		return nil, fmt.Errorf("error preparing query CLearItemStatProgressByStat: %w", err)
+	}
+	if q.clearItemProjectRequirementStmt, err = db.PrepareContext(ctx, clearItemProjectRequirement); err != nil {
+		return nil, fmt.Errorf("error preparing query ClearItemProjectRequirement: %w", err)
+	}
+	if q.clearItemProjectRequirementByProjectIDStmt, err = db.PrepareContext(ctx, clearItemProjectRequirementByProjectID); err != nil {
+		return nil, fmt.Errorf("error preparing query ClearItemProjectRequirementByProjectID: %w", err)
+	}
+	if q.clearItemStatProgressStmt, err = db.PrepareContext(ctx, clearItemStatProgress); err != nil {
+		return nil, fmt.Errorf("error preparing query ClearItemStatProgress: %w", err)
+	}
+	if q.deleteAllProjectRequirementStatsStmt, err = db.PrepareContext(ctx, deleteAllProjectRequirementStats); err != nil {
+		return nil, fmt.Errorf("error preparing query DeleteAllProjectRequirementStats: %w", err)
+	}
+	if q.deleteAllProjectRequirementStatsByStatStmt, err = db.PrepareContext(ctx, deleteAllProjectRequirementStatsByStat); err != nil {
+		return nil, fmt.Errorf("error preparing query DeleteAllProjectRequirementStatsByStat: %w", err)
+	}
+	if q.deleteAllProjectRequirementsStmt, err = db.PrepareContext(ctx, deleteAllProjectRequirements); err != nil {
+		return nil, fmt.Errorf("error preparing query DeleteAllProjectRequirements: %w", err)
+	}
+	if q.deleteAllScopeMembersStmt, err = db.PrepareContext(ctx, deleteAllScopeMembers); err != nil {
+		return nil, fmt.Errorf("error preparing query DeleteAllScopeMembers: %w", err)
+	}
+	if q.deleteItemStmt, err = db.PrepareContext(ctx, deleteItem); err != nil {
+		return nil, fmt.Errorf("error preparing query DeleteItem: %w", err)
+	}
+	if q.deleteItemForRequirementStmt, err = db.PrepareContext(ctx, deleteItemForRequirement); err != nil {
+		return nil, fmt.Errorf("error preparing query DeleteItemForRequirement: %w", err)
+	}
+	if q.deleteItemStatProgressStmt, err = db.PrepareContext(ctx, deleteItemStatProgress); err != nil {
+		return nil, fmt.Errorf("error preparing query DeleteItemStatProgress: %w", err)
+	}
+	if q.deleteProjectStmt, err = db.PrepareContext(ctx, deleteProject); err != nil {
+		return nil, fmt.Errorf("error preparing query DeleteProject: %w", err)
+	}
+	if q.deleteProjectRequirementStmt, err = db.PrepareContext(ctx, deleteProjectRequirement); err != nil {
+		return nil, fmt.Errorf("error preparing query DeleteProjectRequirement: %w", err)
+	}
+	if q.deleteProjectRequirementStatStmt, err = db.PrepareContext(ctx, deleteProjectRequirementStat); err != nil {
+		return nil, fmt.Errorf("error preparing query DeleteProjectRequirementStat: %w", err)
+	}
+	if q.deleteScopeStmt, err = db.PrepareContext(ctx, deleteScope); err != nil {
+		return nil, fmt.Errorf("error preparing query DeleteScope: %w", err)
+	}
+	if q.deleteScopeMemberStmt, err = db.PrepareContext(ctx, deleteScopeMember); err != nil {
+		return nil, fmt.Errorf("error preparing query DeleteScopeMember: %w", err)
+	}
+	if q.deleteStatStmt, err = db.PrepareContext(ctx, deleteStat); err != nil {
+		return nil, fmt.Errorf("error preparing query DeleteStat: %w", err)
+	}
+	if q.getItemStmt, err = db.PrepareContext(ctx, getItem); err != nil {
+		return nil, fmt.Errorf("error preparing query GetItem: %w", err)
+	}
+	if q.getItemStatProgressBetweenStmt, err = db.PrepareContext(ctx, getItemStatProgressBetween); err != nil {
+		return nil, fmt.Errorf("error preparing query GetItemStatProgressBetween: %w", err)
+	}
+	if q.getProjectStmt, err = db.PrepareContext(ctx, getProject); err != nil {
+		return nil, fmt.Errorf("error preparing query GetProject: %w", err)
+	}
+	if q.getProjectRequirementStmt, err = db.PrepareContext(ctx, getProjectRequirement); err != nil {
+		return nil, fmt.Errorf("error preparing query GetProjectRequirement: %w", err)
+	}
+	if q.getScopeStmt, err = db.PrepareContext(ctx, getScope); err != nil {
+		return nil, fmt.Errorf("error preparing query GetScope: %w", err)
+	}
+	if q.getScopeDisplayNameStmt, err = db.PrepareContext(ctx, getScopeDisplayName); err != nil {
+		return nil, fmt.Errorf("error preparing query GetScopeDisplayName: %w", err)
+	}
+	if q.getScopeWithDisplayNameStmt, err = db.PrepareContext(ctx, getScopeWithDisplayName); err != nil {
+		return nil, fmt.Errorf("error preparing query GetScopeWithDisplayName: %w", err)
+	}
+	if q.getStatStmt, err = db.PrepareContext(ctx, getStat); err != nil {
+		return nil, fmt.Errorf("error preparing query GetStat: %w", err)
+	}
+	if q.insertItemStmt, err = db.PrepareContext(ctx, insertItem); err != nil {
+		return nil, fmt.Errorf("error preparing query InsertItem: %w", err)
+	}
+	if q.insertProjectStmt, err = db.PrepareContext(ctx, insertProject); err != nil {
+		return nil, fmt.Errorf("error preparing query InsertProject: %w", err)
+	}
+	if q.insertProjectRequirementStmt, err = db.PrepareContext(ctx, insertProjectRequirement); err != nil {
+		return nil, fmt.Errorf("error preparing query InsertProjectRequirement: %w", err)
+	}
+	if q.insertScopeStmt, err = db.PrepareContext(ctx, insertScope); err != nil {
+		return nil, fmt.Errorf("error preparing query InsertScope: %w", err)
+	}
+	if q.insertStatStmt, err = db.PrepareContext(ctx, insertStat); err != nil {
+		return nil, fmt.Errorf("error preparing query InsertStat: %w", err)
+	}
+	if q.listItemStatProgressStmt, err = db.PrepareContext(ctx, listItemStatProgress); err != nil {
+		return nil, fmt.Errorf("error preparing query ListItemStatProgress: %w", err)
+	}
+	if q.listItemStatProgressMultiStmt, err = db.PrepareContext(ctx, listItemStatProgressMulti); err != nil {
+		return nil, fmt.Errorf("error preparing query ListItemStatProgressMulti: %w", err)
+	}
+	if q.listItemsAcquiredBetweenStmt, err = db.PrepareContext(ctx, listItemsAcquiredBetween); err != nil {
+		return nil, fmt.Errorf("error preparing query ListItemsAcquiredBetween: %w", err)
+	}
+	if q.listItemsByProjectStmt, err = db.PrepareContext(ctx, listItemsByProject); err != nil {
+		return nil, fmt.Errorf("error preparing query ListItemsByProject: %w", err)
+	}
+	if q.listItemsCreatedBetweenStmt, err = db.PrepareContext(ctx, listItemsCreatedBetween); err != nil {
+		return nil, fmt.Errorf("error preparing query ListItemsCreatedBetween: %w", err)
+	}
+	if q.listItemsCreatedBetweenNoScopeStmt, err = db.PrepareContext(ctx, listItemsCreatedBetweenNoScope); err != nil {
+		return nil, fmt.Errorf("error preparing query ListItemsCreatedBetweenNoScope: %w", err)
+	}
+	if q.listItemsLooseBetweenStmt, err = db.PrepareContext(ctx, listItemsLooseBetween); err != nil {
+		return nil, fmt.Errorf("error preparing query ListItemsLooseBetween: %w", err)
+	}
+	if q.listItemsLooseBetweenNoScopeStmt, err = db.PrepareContext(ctx, listItemsLooseBetweenNoScope); err != nil {
+		return nil, fmt.Errorf("error preparing query ListItemsLooseBetweenNoScope: %w", err)
+	}
+	if q.listItemsScheduledBetweenStmt, err = db.PrepareContext(ctx, listItemsScheduledBetween); err != nil {
+		return nil, fmt.Errorf("error preparing query ListItemsScheduledBetween: %w", err)
+	}
+	if q.listItemsScheduledBetweenNoScopeStmt, err = db.PrepareContext(ctx, listItemsScheduledBetweenNoScope); err != nil {
+		return nil, fmt.Errorf("error preparing query ListItemsScheduledBetweenNoScope: %w", err)
+	}
+	if q.listProjectEntriesStmt, err = db.PrepareContext(ctx, listProjectEntries); err != nil {
+		return nil, fmt.Errorf("error preparing query ListProjectEntries: %w", err)
+	}
+	if q.listProjectRequirementStatsStmt, err = db.PrepareContext(ctx, listProjectRequirementStats); err != nil {
+		return nil, fmt.Errorf("error preparing query ListProjectRequirementStats: %w", err)
+	}
+	if q.listProjectRequirementsByProjectIDStmt, err = db.PrepareContext(ctx, listProjectRequirementsByProjectID); err != nil {
+		return nil, fmt.Errorf("error preparing query ListProjectRequirementsByProjectID: %w", err)
+	}
+	if q.listScopeMembersStmt, err = db.PrepareContext(ctx, listScopeMembers); err != nil {
+		return nil, fmt.Errorf("error preparing query ListScopeMembers: %w", err)
+	}
+	if q.listScopesStmt, err = db.PrepareContext(ctx, listScopes); err != nil {
+		return nil, fmt.Errorf("error preparing query ListScopes: %w", err)
+	}
+	if q.listScopesByUserStmt, err = db.PrepareContext(ctx, listScopesByUser); err != nil {
+		return nil, fmt.Errorf("error preparing query ListScopesByUser: %w", err)
+	}
+	if q.listStatsStmt, err = db.PrepareContext(ctx, listStats); err != nil {
+		return nil, fmt.Errorf("error preparing query ListStats: %w", err)
+	}
+	if q.replaceItemStatProgressStmt, err = db.PrepareContext(ctx, replaceItemStatProgress); err != nil {
+		return nil, fmt.Errorf("error preparing query ReplaceItemStatProgress: %w", err)
+	}
+	if q.replaceProjectRequirementStatStmt, err = db.PrepareContext(ctx, replaceProjectRequirementStat); err != nil {
+		return nil, fmt.Errorf("error preparing query ReplaceProjectRequirementStat: %w", err)
+	}
+	if q.updateItemStmt, err = db.PrepareContext(ctx, updateItem); err != nil {
+		return nil, fmt.Errorf("error preparing query UpdateItem: %w", err)
+	}
+	if q.updateProjectStmt, err = db.PrepareContext(ctx, updateProject); err != nil {
+		return nil, fmt.Errorf("error preparing query UpdateProject: %w", err)
+	}
+	if q.updateProjectRequirementStmt, err = db.PrepareContext(ctx, updateProjectRequirement); err != nil {
+		return nil, fmt.Errorf("error preparing query UpdateProjectRequirement: %w", err)
+	}
+	if q.updateScopeStmt, err = db.PrepareContext(ctx, updateScope); err != nil {
+		return nil, fmt.Errorf("error preparing query UpdateScope: %w", err)
+	}
+	if q.updateScopeMemberStmt, err = db.PrepareContext(ctx, updateScopeMember); err != nil {
+		return nil, fmt.Errorf("error preparing query UpdateScopeMember: %w", err)
+	}
+	if q.updateStatStmt, err = db.PrepareContext(ctx, updateStat); err != nil {
+		return nil, fmt.Errorf("error preparing query UpdateStat: %w", err)
+	}
+	return &q, nil
+}
+
+func (q *Queries) Close() error {
+	var err error
+	if q.cLearItemStatProgressByStatStmt != nil {
+		if cerr := q.cLearItemStatProgressByStatStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing cLearItemStatProgressByStatStmt: %w", cerr)
+		}
+	}
+	if q.clearItemProjectRequirementStmt != nil {
+		if cerr := q.clearItemProjectRequirementStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing clearItemProjectRequirementStmt: %w", cerr)
+		}
+	}
+	if q.clearItemProjectRequirementByProjectIDStmt != nil {
+		if cerr := q.clearItemProjectRequirementByProjectIDStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing clearItemProjectRequirementByProjectIDStmt: %w", cerr)
+		}
+	}
+	if q.clearItemStatProgressStmt != nil {
+		if cerr := q.clearItemStatProgressStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing clearItemStatProgressStmt: %w", cerr)
+		}
+	}
+	if q.deleteAllProjectRequirementStatsStmt != nil {
+		if cerr := q.deleteAllProjectRequirementStatsStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing deleteAllProjectRequirementStatsStmt: %w", cerr)
+		}
+	}
+	if q.deleteAllProjectRequirementStatsByStatStmt != nil {
+		if cerr := q.deleteAllProjectRequirementStatsByStatStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing deleteAllProjectRequirementStatsByStatStmt: %w", cerr)
+		}
+	}
+	if q.deleteAllProjectRequirementsStmt != nil {
+		if cerr := q.deleteAllProjectRequirementsStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing deleteAllProjectRequirementsStmt: %w", cerr)
+		}
+	}
+	if q.deleteAllScopeMembersStmt != nil {
+		if cerr := q.deleteAllScopeMembersStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing deleteAllScopeMembersStmt: %w", cerr)
+		}
+	}
+	if q.deleteItemStmt != nil {
+		if cerr := q.deleteItemStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing deleteItemStmt: %w", cerr)
+		}
+	}
+	if q.deleteItemForRequirementStmt != nil {
+		if cerr := q.deleteItemForRequirementStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing deleteItemForRequirementStmt: %w", cerr)
+		}
+	}
+	if q.deleteItemStatProgressStmt != nil {
+		if cerr := q.deleteItemStatProgressStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing deleteItemStatProgressStmt: %w", cerr)
+		}
+	}
+	if q.deleteProjectStmt != nil {
+		if cerr := q.deleteProjectStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing deleteProjectStmt: %w", cerr)
+		}
+	}
+	if q.deleteProjectRequirementStmt != nil {
+		if cerr := q.deleteProjectRequirementStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing deleteProjectRequirementStmt: %w", cerr)
+		}
+	}
+	if q.deleteProjectRequirementStatStmt != nil {
+		if cerr := q.deleteProjectRequirementStatStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing deleteProjectRequirementStatStmt: %w", cerr)
+		}
+	}
+	if q.deleteScopeStmt != nil {
+		if cerr := q.deleteScopeStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing deleteScopeStmt: %w", cerr)
+		}
+	}
+	if q.deleteScopeMemberStmt != nil {
+		if cerr := q.deleteScopeMemberStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing deleteScopeMemberStmt: %w", cerr)
+		}
+	}
+	if q.deleteStatStmt != nil {
+		if cerr := q.deleteStatStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing deleteStatStmt: %w", cerr)
+		}
+	}
+	if q.getItemStmt != nil {
+		if cerr := q.getItemStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing getItemStmt: %w", cerr)
+		}
+	}
+	if q.getItemStatProgressBetweenStmt != nil {
+		if cerr := q.getItemStatProgressBetweenStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing getItemStatProgressBetweenStmt: %w", cerr)
+		}
+	}
+	if q.getProjectStmt != nil {
+		if cerr := q.getProjectStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing getProjectStmt: %w", cerr)
+		}
+	}
+	if q.getProjectRequirementStmt != nil {
+		if cerr := q.getProjectRequirementStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing getProjectRequirementStmt: %w", cerr)
+		}
+	}
+	if q.getScopeStmt != nil {
+		if cerr := q.getScopeStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing getScopeStmt: %w", cerr)
+		}
+	}
+	if q.getScopeDisplayNameStmt != nil {
+		if cerr := q.getScopeDisplayNameStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing getScopeDisplayNameStmt: %w", cerr)
+		}
+	}
+	if q.getScopeWithDisplayNameStmt != nil {
+		if cerr := q.getScopeWithDisplayNameStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing getScopeWithDisplayNameStmt: %w", cerr)
+		}
+	}
+	if q.getStatStmt != nil {
+		if cerr := q.getStatStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing getStatStmt: %w", cerr)
+		}
+	}
+	if q.insertItemStmt != nil {
+		if cerr := q.insertItemStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing insertItemStmt: %w", cerr)
+		}
+	}
+	if q.insertProjectStmt != nil {
+		if cerr := q.insertProjectStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing insertProjectStmt: %w", cerr)
+		}
+	}
+	if q.insertProjectRequirementStmt != nil {
+		if cerr := q.insertProjectRequirementStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing insertProjectRequirementStmt: %w", cerr)
+		}
+	}
+	if q.insertScopeStmt != nil {
+		if cerr := q.insertScopeStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing insertScopeStmt: %w", cerr)
+		}
+	}
+	if q.insertStatStmt != nil {
+		if cerr := q.insertStatStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing insertStatStmt: %w", cerr)
+		}
+	}
+	if q.listItemStatProgressStmt != nil {
+		if cerr := q.listItemStatProgressStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing listItemStatProgressStmt: %w", cerr)
+		}
+	}
+	if q.listItemStatProgressMultiStmt != nil {
+		if cerr := q.listItemStatProgressMultiStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing listItemStatProgressMultiStmt: %w", cerr)
+		}
+	}
+	if q.listItemsAcquiredBetweenStmt != nil {
+		if cerr := q.listItemsAcquiredBetweenStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing listItemsAcquiredBetweenStmt: %w", cerr)
+		}
+	}
+	if q.listItemsByProjectStmt != nil {
+		if cerr := q.listItemsByProjectStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing listItemsByProjectStmt: %w", cerr)
+		}
+	}
+	if q.listItemsCreatedBetweenStmt != nil {
+		if cerr := q.listItemsCreatedBetweenStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing listItemsCreatedBetweenStmt: %w", cerr)
+		}
+	}
+	if q.listItemsCreatedBetweenNoScopeStmt != nil {
+		if cerr := q.listItemsCreatedBetweenNoScopeStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing listItemsCreatedBetweenNoScopeStmt: %w", cerr)
+		}
+	}
+	if q.listItemsLooseBetweenStmt != nil {
+		if cerr := q.listItemsLooseBetweenStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing listItemsLooseBetweenStmt: %w", cerr)
+		}
+	}
+	if q.listItemsLooseBetweenNoScopeStmt != nil {
+		if cerr := q.listItemsLooseBetweenNoScopeStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing listItemsLooseBetweenNoScopeStmt: %w", cerr)
+		}
+	}
+	if q.listItemsScheduledBetweenStmt != nil {
+		if cerr := q.listItemsScheduledBetweenStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing listItemsScheduledBetweenStmt: %w", cerr)
+		}
+	}
+	if q.listItemsScheduledBetweenNoScopeStmt != nil {
+		if cerr := q.listItemsScheduledBetweenNoScopeStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing listItemsScheduledBetweenNoScopeStmt: %w", cerr)
+		}
+	}
+	if q.listProjectEntriesStmt != nil {
+		if cerr := q.listProjectEntriesStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing listProjectEntriesStmt: %w", cerr)
+		}
+	}
+	if q.listProjectRequirementStatsStmt != nil {
+		if cerr := q.listProjectRequirementStatsStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing listProjectRequirementStatsStmt: %w", cerr)
+		}
+	}
+	if q.listProjectRequirementsByProjectIDStmt != nil {
+		if cerr := q.listProjectRequirementsByProjectIDStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing listProjectRequirementsByProjectIDStmt: %w", cerr)
+		}
+	}
+	if q.listScopeMembersStmt != nil {
+		if cerr := q.listScopeMembersStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing listScopeMembersStmt: %w", cerr)
+		}
+	}
+	if q.listScopesStmt != nil {
+		if cerr := q.listScopesStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing listScopesStmt: %w", cerr)
+		}
+	}
+	if q.listScopesByUserStmt != nil {
+		if cerr := q.listScopesByUserStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing listScopesByUserStmt: %w", cerr)
+		}
+	}
+	if q.listStatsStmt != nil {
+		if cerr := q.listStatsStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing listStatsStmt: %w", cerr)
+		}
+	}
+	if q.replaceItemStatProgressStmt != nil {
+		if cerr := q.replaceItemStatProgressStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing replaceItemStatProgressStmt: %w", cerr)
+		}
+	}
+	if q.replaceProjectRequirementStatStmt != nil {
+		if cerr := q.replaceProjectRequirementStatStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing replaceProjectRequirementStatStmt: %w", cerr)
+		}
+	}
+	if q.updateItemStmt != nil {
+		if cerr := q.updateItemStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing updateItemStmt: %w", cerr)
+		}
+	}
+	if q.updateProjectStmt != nil {
+		if cerr := q.updateProjectStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing updateProjectStmt: %w", cerr)
+		}
+	}
+	if q.updateProjectRequirementStmt != nil {
+		if cerr := q.updateProjectRequirementStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing updateProjectRequirementStmt: %w", cerr)
+		}
+	}
+	if q.updateScopeStmt != nil {
+		if cerr := q.updateScopeStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing updateScopeStmt: %w", cerr)
+		}
+	}
+	if q.updateScopeMemberStmt != nil {
+		if cerr := q.updateScopeMemberStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing updateScopeMemberStmt: %w", cerr)
+		}
+	}
+	if q.updateStatStmt != nil {
+		if cerr := q.updateStatStmt.Close(); cerr != nil {
+			err = fmt.Errorf("error closing updateStatStmt: %w", cerr)
+		}
+	}
+	return err
+}
+
+func (q *Queries) exec(ctx context.Context, stmt *sql.Stmt, query string, args ...interface{}) (sql.Result, error) {
+	switch {
+	case stmt != nil && q.tx != nil:
+		return q.tx.StmtContext(ctx, stmt).ExecContext(ctx, args...)
+	case stmt != nil:
+		return stmt.ExecContext(ctx, args...)
+	default:
+		return q.db.ExecContext(ctx, query, args...)
+	}
+}
+
+func (q *Queries) query(ctx context.Context, stmt *sql.Stmt, query string, args ...interface{}) (*sql.Rows, error) {
+	switch {
+	case stmt != nil && q.tx != nil:
+		return q.tx.StmtContext(ctx, stmt).QueryContext(ctx, args...)
+	case stmt != nil:
+		return stmt.QueryContext(ctx, args...)
+	default:
+		return q.db.QueryContext(ctx, query, args...)
+	}
+}
+
+func (q *Queries) queryRow(ctx context.Context, stmt *sql.Stmt, query string, args ...interface{}) *sql.Row {
+	switch {
+	case stmt != nil && q.tx != nil:
+		return q.tx.StmtContext(ctx, stmt).QueryRowContext(ctx, args...)
+	case stmt != nil:
+		return stmt.QueryRowContext(ctx, args...)
+	default:
+		return q.db.QueryRowContext(ctx, query, args...)
+	}
+}
+
+type Queries struct {
+	db                                         DBTX
+	tx                                         *sql.Tx
+	cLearItemStatProgressByStatStmt            *sql.Stmt
+	clearItemProjectRequirementStmt            *sql.Stmt
+	clearItemProjectRequirementByProjectIDStmt *sql.Stmt
+	clearItemStatProgressStmt                  *sql.Stmt
+	deleteAllProjectRequirementStatsStmt       *sql.Stmt
+	deleteAllProjectRequirementStatsByStatStmt *sql.Stmt
+	deleteAllProjectRequirementsStmt           *sql.Stmt
+	deleteAllScopeMembersStmt                  *sql.Stmt
+	deleteItemStmt                             *sql.Stmt
+	deleteItemForRequirementStmt               *sql.Stmt
+	deleteItemStatProgressStmt                 *sql.Stmt
+	deleteProjectStmt                          *sql.Stmt
+	deleteProjectRequirementStmt               *sql.Stmt
+	deleteProjectRequirementStatStmt           *sql.Stmt
+	deleteScopeStmt                            *sql.Stmt
+	deleteScopeMemberStmt                      *sql.Stmt
+	deleteStatStmt                             *sql.Stmt
+	getItemStmt                                *sql.Stmt
+	getItemStatProgressBetweenStmt             *sql.Stmt
+	getProjectStmt                             *sql.Stmt
+	getProjectRequirementStmt                  *sql.Stmt
+	getScopeStmt                               *sql.Stmt
+	getScopeDisplayNameStmt                    *sql.Stmt
+	getScopeWithDisplayNameStmt                *sql.Stmt
+	getStatStmt                                *sql.Stmt
+	insertItemStmt                             *sql.Stmt
+	insertProjectStmt                          *sql.Stmt
+	insertProjectRequirementStmt               *sql.Stmt
+	insertScopeStmt                            *sql.Stmt
+	insertStatStmt                             *sql.Stmt
+	listItemStatProgressStmt                   *sql.Stmt
+	listItemStatProgressMultiStmt              *sql.Stmt
+	listItemsAcquiredBetweenStmt               *sql.Stmt
+	listItemsByProjectStmt                     *sql.Stmt
+	listItemsCreatedBetweenStmt                *sql.Stmt
+	listItemsCreatedBetweenNoScopeStmt         *sql.Stmt
+	listItemsLooseBetweenStmt                  *sql.Stmt
+	listItemsLooseBetweenNoScopeStmt           *sql.Stmt
+	listItemsScheduledBetweenStmt              *sql.Stmt
+	listItemsScheduledBetweenNoScopeStmt       *sql.Stmt
+	listProjectEntriesStmt                     *sql.Stmt
+	listProjectRequirementStatsStmt            *sql.Stmt
+	listProjectRequirementsByProjectIDStmt     *sql.Stmt
+	listScopeMembersStmt                       *sql.Stmt
+	listScopesStmt                             *sql.Stmt
+	listScopesByUserStmt                       *sql.Stmt
+	listStatsStmt                              *sql.Stmt
+	replaceItemStatProgressStmt                *sql.Stmt
+	replaceProjectRequirementStatStmt          *sql.Stmt
+	updateItemStmt                             *sql.Stmt
+	updateProjectStmt                          *sql.Stmt
+	updateProjectRequirementStmt               *sql.Stmt
+	updateScopeStmt                            *sql.Stmt
+	updateScopeMemberStmt                      *sql.Stmt
+	updateStatStmt                             *sql.Stmt
+}
+
+func (q *Queries) WithTx(tx *sql.Tx) *Queries {
+	return &Queries{
+		db:                              tx,
+		tx:                              tx,
+		cLearItemStatProgressByStatStmt: q.cLearItemStatProgressByStatStmt,
+		clearItemProjectRequirementStmt: q.clearItemProjectRequirementStmt,
+		clearItemProjectRequirementByProjectIDStmt: q.clearItemProjectRequirementByProjectIDStmt,
+		clearItemStatProgressStmt:                  q.clearItemStatProgressStmt,
+		deleteAllProjectRequirementStatsStmt:       q.deleteAllProjectRequirementStatsStmt,
+		deleteAllProjectRequirementStatsByStatStmt: q.deleteAllProjectRequirementStatsByStatStmt,
+		deleteAllProjectRequirementsStmt:           q.deleteAllProjectRequirementsStmt,
+		deleteAllScopeMembersStmt:                  q.deleteAllScopeMembersStmt,
+		deleteItemStmt:                             q.deleteItemStmt,
+		deleteItemForRequirementStmt:               q.deleteItemForRequirementStmt,
+		deleteItemStatProgressStmt:                 q.deleteItemStatProgressStmt,
+		deleteProjectStmt:                          q.deleteProjectStmt,
+		deleteProjectRequirementStmt:               q.deleteProjectRequirementStmt,
+		deleteProjectRequirementStatStmt:           q.deleteProjectRequirementStatStmt,
+		deleteScopeStmt:                            q.deleteScopeStmt,
+		deleteScopeMemberStmt:                      q.deleteScopeMemberStmt,
+		deleteStatStmt:                             q.deleteStatStmt,
+		getItemStmt:                                q.getItemStmt,
+		getItemStatProgressBetweenStmt:             q.getItemStatProgressBetweenStmt,
+		getProjectStmt:                             q.getProjectStmt,
+		getProjectRequirementStmt:                  q.getProjectRequirementStmt,
+		getScopeStmt:                               q.getScopeStmt,
+		getScopeDisplayNameStmt:                    q.getScopeDisplayNameStmt,
+		getScopeWithDisplayNameStmt:                q.getScopeWithDisplayNameStmt,
+		getStatStmt:                                q.getStatStmt,
+		insertItemStmt:                             q.insertItemStmt,
+		insertProjectStmt:                          q.insertProjectStmt,
+		insertProjectRequirementStmt:               q.insertProjectRequirementStmt,
+		insertScopeStmt:                            q.insertScopeStmt,
+		insertStatStmt:                             q.insertStatStmt,
+		listItemStatProgressStmt:                   q.listItemStatProgressStmt,
+		listItemStatProgressMultiStmt:              q.listItemStatProgressMultiStmt,
+		listItemsAcquiredBetweenStmt:               q.listItemsAcquiredBetweenStmt,
+		listItemsByProjectStmt:                     q.listItemsByProjectStmt,
+		listItemsCreatedBetweenStmt:                q.listItemsCreatedBetweenStmt,
+		listItemsCreatedBetweenNoScopeStmt:         q.listItemsCreatedBetweenNoScopeStmt,
+		listItemsLooseBetweenStmt:                  q.listItemsLooseBetweenStmt,
+		listItemsLooseBetweenNoScopeStmt:           q.listItemsLooseBetweenNoScopeStmt,
+		listItemsScheduledBetweenStmt:              q.listItemsScheduledBetweenStmt,
+		listItemsScheduledBetweenNoScopeStmt:       q.listItemsScheduledBetweenNoScopeStmt,
+		listProjectEntriesStmt:                     q.listProjectEntriesStmt,
+		listProjectRequirementStatsStmt:            q.listProjectRequirementStatsStmt,
+		listProjectRequirementsByProjectIDStmt:     q.listProjectRequirementsByProjectIDStmt,
+		listScopeMembersStmt:                       q.listScopeMembersStmt,
+		listScopesStmt:                             q.listScopesStmt,
+		listScopesByUserStmt:                       q.listScopesByUserStmt,
+		listStatsStmt:                              q.listStatsStmt,
+		replaceItemStatProgressStmt:                q.replaceItemStatProgressStmt,
+		replaceProjectRequirementStatStmt:          q.replaceProjectRequirementStatStmt,
+		updateItemStmt:                             q.updateItemStmt,
+		updateProjectStmt:                          q.updateProjectStmt,
+		updateProjectRequirementStmt:               q.updateProjectRequirementStmt,
+		updateScopeStmt:                            q.updateScopeStmt,
+		updateScopeMemberStmt:                      q.updateScopeMemberStmt,
+		updateStatStmt:                             q.updateStatStmt,
+	}
+}

internal/database/mysql/mysqlcore/item.sql.go

@@ -0,0 +1,835 @@
+// Code generated by sqlc. DO NOT EDIT.
+// versions:
+//   sqlc v1.13.0
+// source: item.sql
+
+package mysqlcore
+
+import (
+	"context"
+	"database/sql"
+	"time"
+
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/sqltypes"
+)
+
+const cLearItemStatProgressByStat = `-- name: CLearItemStatProgressByStat :exec
+DELETE FROM item_stat_progress WHERE stat_id = ?
+`
+
+func (q *Queries) CLearItemStatProgressByStat(ctx context.Context, statID int) error {
+	_, err := q.exec(ctx, q.cLearItemStatProgressByStatStmt, cLearItemStatProgressByStat, statID)
+	return err
+}
+
+const clearItemProjectRequirement = `-- name: ClearItemProjectRequirement :exec
+UPDATE item SET project_requirement_id = NULL WHERE project_requirement_id = ?
+`
+
+func (q *Queries) ClearItemProjectRequirement(ctx context.Context, projectRequirementID sql.NullInt32) error {
+	_, err := q.exec(ctx, q.clearItemProjectRequirementStmt, clearItemProjectRequirement, projectRequirementID)
+	return err
+}
+
+const clearItemProjectRequirementByProjectID = `-- name: ClearItemProjectRequirementByProjectID :exec
+UPDATE item i
+LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
+SET i.project_requirement_id = NULL
+WHERE pr.project_id = ?
+`
+
+func (q *Queries) ClearItemProjectRequirementByProjectID(ctx context.Context, projectID int) error {
+	_, err := q.exec(ctx, q.clearItemProjectRequirementByProjectIDStmt, clearItemProjectRequirementByProjectID, projectID)
+	return err
+}
+
+const clearItemStatProgress = `-- name: ClearItemStatProgress :exec
+DELETE FROM item_stat_progress WHERE item_id = ?
+`
+
+func (q *Queries) ClearItemStatProgress(ctx context.Context, itemID int) error {
+	_, err := q.exec(ctx, q.clearItemStatProgressStmt, clearItemStatProgress, itemID)
+	return err
+}
+
+const deleteItem = `-- name: DeleteItem :exec
+DELETE FROM item WHERE id = ?
+`
+
+func (q *Queries) DeleteItem(ctx context.Context, id int) error {
+	_, err := q.exec(ctx, q.deleteItemStmt, deleteItem, id)
+	return err
+}
+
+const deleteItemForRequirement = `-- name: DeleteItemForRequirement :exec
+DELETE FROM item WHERE project_requirement_id = ?
+`
+
+func (q *Queries) DeleteItemForRequirement(ctx context.Context, projectRequirementID sql.NullInt32) error {
+	_, err := q.exec(ctx, q.deleteItemForRequirementStmt, deleteItemForRequirement, projectRequirementID)
+	return err
+}
+
+const deleteItemStatProgress = `-- name: DeleteItemStatProgress :exec
+DELETE FROM item_stat_progress WHERE item_id = ? AND stat_id = ?
+`
+
+type DeleteItemStatProgressParams struct {
+	ItemID int
+	StatID int
+}
+
+func (q *Queries) DeleteItemStatProgress(ctx context.Context, arg DeleteItemStatProgressParams) error {
+	_, err := q.exec(ctx, q.deleteItemStatProgressStmt, deleteItemStatProgress, arg.ItemID, arg.StatID)
+	return err
+}
+
+const getItem = `-- name: GetItem :one
+SELECT i.id, i.scope_id, i.project_requirement_id, i.name, i.description, i.created_time, i.created_user_id, i.acquired_time, i.scheduled_date, pr.project_id FROM item i
+LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
+WHERE i.id = ?
+`
+
+type GetItemRow struct {
+	ID                   int
+	ScopeID              int
+	ProjectRequirementID sql.NullInt32
+	Name                 string
+	Description          string
+	CreatedTime          time.Time
+	CreatedUserID        string
+	AcquiredTime         sql.NullTime
+	ScheduledDate        sqltypes.NullDate
+	ProjectID            sql.NullInt32
+}
+
+func (q *Queries) GetItem(ctx context.Context, id int) (GetItemRow, error) {
+	row := q.queryRow(ctx, q.getItemStmt, getItem, id)
+	var i GetItemRow
+	err := row.Scan(
+		&i.ID,
+		&i.ScopeID,
+		&i.ProjectRequirementID,
+		&i.Name,
+		&i.Description,
+		&i.CreatedTime,
+		&i.CreatedUserID,
+		&i.AcquiredTime,
+		&i.ScheduledDate,
+		&i.ProjectID,
+	)
+	return i, err
+}
+
+const getItemStatProgressBetween = `-- name: GetItemStatProgressBetween :one
+SELECT s.id, s.name, s.weight, SUM(isp.acquired), SUM(isp.required) FROM item i
+LEFT JOIN item_stat_progress isp on i.id = isp.item_id
+LEFT JOIN stat s on isp.stat_id = s.id
+WHERE i.acquired_time >= ?
+  AND i.acquired_time < ?
+  AND i.scope_id = ?
+GROUP BY stat_id
+`
+
+type GetItemStatProgressBetweenParams struct {
+	AcquiredTime   sql.NullTime
+	AcquiredTime_2 sql.NullTime
+	ScopeID        int
+}
+
+type GetItemStatProgressBetweenRow struct {
+	ID     sql.NullInt32
+	Name   sql.NullString
+	Weight float64
+	Sum    interface{}
+	Sum_2  interface{}
+}
+
+func (q *Queries) GetItemStatProgressBetween(ctx context.Context, arg GetItemStatProgressBetweenParams) (GetItemStatProgressBetweenRow, error) {
+	row := q.queryRow(ctx, q.getItemStatProgressBetweenStmt, getItemStatProgressBetween, arg.AcquiredTime, arg.AcquiredTime_2, arg.ScopeID)
+	var i GetItemStatProgressBetweenRow
+	err := row.Scan(
+		&i.ID,
+		&i.Name,
+		&i.Weight,
+		&i.Sum,
+		&i.Sum_2,
+	)
+	return i, err
+}
+
+const insertItem = `-- name: InsertItem :execresult
+INSERT INTO item (scope_id, project_requirement_id, name, description, created_time, created_user_id, acquired_time, scheduled_date)
+VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+`
+
+type InsertItemParams struct {
+	ScopeID              int
+	ProjectRequirementID sql.NullInt32
+	Name                 string
+	Description          string
+	CreatedTime          time.Time
+	CreatedUserID        string
+	AcquiredTime         sql.NullTime
+	ScheduledDate        sqltypes.NullDate
+}
+
+func (q *Queries) InsertItem(ctx context.Context, arg InsertItemParams) (sql.Result, error) {
+	return q.exec(ctx, q.insertItemStmt, insertItem,
+		arg.ScopeID,
+		arg.ProjectRequirementID,
+		arg.Name,
+		arg.Description,
+		arg.CreatedTime,
+		arg.CreatedUserID,
+		arg.AcquiredTime,
+		arg.ScheduledDate,
+	)
+}
+
+const listItemStatProgress = `-- name: ListItemStatProgress :many
+SELECT isp.required, isp.acquired, s.id, s.name, s.weight FROM item_stat_progress isp
+LEFT JOIN stat s ON s.id = isp.stat_id
+WHERE item_id = ?
+`
+
+type ListItemStatProgressRow struct {
+	Required int
+	Acquired int
+	ID       sql.NullInt32
+	Name     sql.NullString
+	Weight   float64
+}
+
+func (q *Queries) ListItemStatProgress(ctx context.Context, itemID int) ([]ListItemStatProgressRow, error) {
+	rows, err := q.query(ctx, q.listItemStatProgressStmt, listItemStatProgress, itemID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []ListItemStatProgressRow{}
+	for rows.Next() {
+		var i ListItemStatProgressRow
+		if err := rows.Scan(
+			&i.Required,
+			&i.Acquired,
+			&i.ID,
+			&i.Name,
+			&i.Weight,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Close(); err != nil {
+		return nil, err
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const listItemStatProgressMulti = `-- name: ListItemStatProgressMulti :many
+SELECT isp.item_id, isp.required, isp.acquired, s.id, s.name, s.weight FROM item_stat_progress isp
+LEFT JOIN stat s ON s.id = isp.stat_id
+WHERE item_id IN (?, ?, ?, ?, ?, ?, ?, ?)
+`
+
+type ListItemStatProgressMultiParams struct {
+	ItemID   int
+	ItemID_2 int
+	ItemID_3 int
+	ItemID_4 int
+	ItemID_5 int
+	ItemID_6 int
+	ItemID_7 int
+	ItemID_8 int
+}
+
+type ListItemStatProgressMultiRow struct {
+	ItemID   int
+	Required int
+	Acquired int
+	ID       sql.NullInt32
+	Name     sql.NullString
+	Weight   float64
+}
+
+func (q *Queries) ListItemStatProgressMulti(ctx context.Context, arg ListItemStatProgressMultiParams) ([]ListItemStatProgressMultiRow, error) {
+	rows, err := q.query(ctx, q.listItemStatProgressMultiStmt, listItemStatProgressMulti,
+		arg.ItemID,
+		arg.ItemID_2,
+		arg.ItemID_3,
+		arg.ItemID_4,
+		arg.ItemID_5,
+		arg.ItemID_6,
+		arg.ItemID_7,
+		arg.ItemID_8,
+	)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []ListItemStatProgressMultiRow{}
+	for rows.Next() {
+		var i ListItemStatProgressMultiRow
+		if err := rows.Scan(
+			&i.ItemID,
+			&i.Required,
+			&i.Acquired,
+			&i.ID,
+			&i.Name,
+			&i.Weight,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Close(); err != nil {
+		return nil, err
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const listItemsAcquiredBetween = `-- name: ListItemsAcquiredBetween :many
+SELECT i.id, i.scope_id, i.project_requirement_id, i.name, i.description, i.created_time, i.created_user_id, i.acquired_time, i.scheduled_date, pr.project_id FROM item i
+LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
+WHERE i.acquired_time >= ?
+  AND i.acquired_time <= ?
+  AND i.scope_id = ?
+ORDER BY acquired_time DESC, created_time DESC
+`
+
+type ListItemsAcquiredBetweenParams struct {
+	AcquiredTime   sql.NullTime
+	AcquiredTime_2 sql.NullTime
+	ScopeID        int
+}
+
+type ListItemsAcquiredBetweenRow struct {
+	ID                   int
+	ScopeID              int
+	ProjectRequirementID sql.NullInt32
+	Name                 string
+	Description          string
+	CreatedTime          time.Time
+	CreatedUserID        string
+	AcquiredTime         sql.NullTime
+	ScheduledDate        sqltypes.NullDate
+	ProjectID            sql.NullInt32
+}
+
+func (q *Queries) ListItemsAcquiredBetween(ctx context.Context, arg ListItemsAcquiredBetweenParams) ([]ListItemsAcquiredBetweenRow, error) {
+	rows, err := q.query(ctx, q.listItemsAcquiredBetweenStmt, listItemsAcquiredBetween, arg.AcquiredTime, arg.AcquiredTime_2, arg.ScopeID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []ListItemsAcquiredBetweenRow{}
+	for rows.Next() {
+		var i ListItemsAcquiredBetweenRow
+		if err := rows.Scan(
+			&i.ID,
+			&i.ScopeID,
+			&i.ProjectRequirementID,
+			&i.Name,
+			&i.Description,
+			&i.CreatedTime,
+			&i.CreatedUserID,
+			&i.AcquiredTime,
+			&i.ScheduledDate,
+			&i.ProjectID,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Close(); err != nil {
+		return nil, err
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const listItemsByProject = `-- name: ListItemsByProject :many
+SELECT i.id, i.scope_id, i.project_requirement_id, i.name, i.description, i.created_time, i.created_user_id, i.acquired_time, i.scheduled_date, pr.project_id FROM item i
+LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
+WHERE pr.project_id = ?
+`
+
+type ListItemsByProjectRow struct {
+	ID                   int
+	ScopeID              int
+	ProjectRequirementID sql.NullInt32
+	Name                 string
+	Description          string
+	CreatedTime          time.Time
+	CreatedUserID        string
+	AcquiredTime         sql.NullTime
+	ScheduledDate        sqltypes.NullDate
+	ProjectID            sql.NullInt32
+}
+
+func (q *Queries) ListItemsByProject(ctx context.Context, projectID int) ([]ListItemsByProjectRow, error) {
+	rows, err := q.query(ctx, q.listItemsByProjectStmt, listItemsByProject, projectID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []ListItemsByProjectRow{}
+	for rows.Next() {
+		var i ListItemsByProjectRow
+		if err := rows.Scan(
+			&i.ID,
+			&i.ScopeID,
+			&i.ProjectRequirementID,
+			&i.Name,
+			&i.Description,
+			&i.CreatedTime,
+			&i.CreatedUserID,
+			&i.AcquiredTime,
+			&i.ScheduledDate,
+			&i.ProjectID,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Close(); err != nil {
+		return nil, err
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const listItemsCreatedBetween = `-- name: ListItemsCreatedBetween :many
+SELECT i.id, i.scope_id, i.project_requirement_id, i.name, i.description, i.created_time, i.created_user_id, i.acquired_time, i.scheduled_date, pr.project_id FROM item i
+LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
+WHERE i.created_time >= ?
+  AND i.created_time <= ?
+  AND i.scope_id = ?
+ORDER BY created_time DESC
+`
+
+type ListItemsCreatedBetweenParams struct {
+	CreatedTime   time.Time
+	CreatedTime_2 time.Time
+	ScopeID       int
+}
+
+type ListItemsCreatedBetweenRow struct {
+	ID                   int
+	ScopeID              int
+	ProjectRequirementID sql.NullInt32
+	Name                 string
+	Description          string
+	CreatedTime          time.Time
+	CreatedUserID        string
+	AcquiredTime         sql.NullTime
+	ScheduledDate        sqltypes.NullDate
+	ProjectID            sql.NullInt32
+}
+
+func (q *Queries) ListItemsCreatedBetween(ctx context.Context, arg ListItemsCreatedBetweenParams) ([]ListItemsCreatedBetweenRow, error) {
+	rows, err := q.query(ctx, q.listItemsCreatedBetweenStmt, listItemsCreatedBetween, arg.CreatedTime, arg.CreatedTime_2, arg.ScopeID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []ListItemsCreatedBetweenRow{}
+	for rows.Next() {
+		var i ListItemsCreatedBetweenRow
+		if err := rows.Scan(
+			&i.ID,
+			&i.ScopeID,
+			&i.ProjectRequirementID,
+			&i.Name,
+			&i.Description,
+			&i.CreatedTime,
+			&i.CreatedUserID,
+			&i.AcquiredTime,
+			&i.ScheduledDate,
+			&i.ProjectID,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Close(); err != nil {
+		return nil, err
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const listItemsCreatedBetweenNoScope = `-- name: ListItemsCreatedBetweenNoScope :many
+SELECT i.id, i.scope_id, i.project_requirement_id, i.name, i.description, i.created_time, i.created_user_id, i.acquired_time, i.scheduled_date, pr.project_id FROM item i
+LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
+WHERE i.created_time >= ?
+  AND i.created_time < ?
+`
+
+type ListItemsCreatedBetweenNoScopeParams struct {
+	CreatedTime   time.Time
+	CreatedTime_2 time.Time
+}
+
+type ListItemsCreatedBetweenNoScopeRow struct {
+	ID                   int
+	ScopeID              int
+	ProjectRequirementID sql.NullInt32
+	Name                 string
+	Description          string
+	CreatedTime          time.Time
+	CreatedUserID        string
+	AcquiredTime         sql.NullTime
+	ScheduledDate        sqltypes.NullDate
+	ProjectID            sql.NullInt32
+}
+
+func (q *Queries) ListItemsCreatedBetweenNoScope(ctx context.Context, arg ListItemsCreatedBetweenNoScopeParams) ([]ListItemsCreatedBetweenNoScopeRow, error) {
+	rows, err := q.query(ctx, q.listItemsCreatedBetweenNoScopeStmt, listItemsCreatedBetweenNoScope, arg.CreatedTime, arg.CreatedTime_2)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []ListItemsCreatedBetweenNoScopeRow{}
+	for rows.Next() {
+		var i ListItemsCreatedBetweenNoScopeRow
+		if err := rows.Scan(
+			&i.ID,
+			&i.ScopeID,
+			&i.ProjectRequirementID,
+			&i.Name,
+			&i.Description,
+			&i.CreatedTime,
+			&i.CreatedUserID,
+			&i.AcquiredTime,
+			&i.ScheduledDate,
+			&i.ProjectID,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Close(); err != nil {
+		return nil, err
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const listItemsLooseBetween = `-- name: ListItemsLooseBetween :many
+SELECT i.id, i.scope_id, i.project_requirement_id, i.name, i.description, i.created_time, i.created_user_id, i.acquired_time, i.scheduled_date, pr.project_id FROM item i
+LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
+WHERE i.created_time >= ?
+  AND i.created_time <= ?
+  AND i.scope_id = ?
+  AND i.scheduled_date IS NULL
+  AND i.acquired_time IS NULL
+  AND i.project_requirement_id IS NULL
+ORDER BY created_time DESC
+`
+
+type ListItemsLooseBetweenParams struct {
+	CreatedTime   time.Time
+	CreatedTime_2 time.Time
+	ScopeID       int
+}
+
+type ListItemsLooseBetweenRow struct {
+	ID                   int
+	ScopeID              int
+	ProjectRequirementID sql.NullInt32
+	Name                 string
+	Description          string
+	CreatedTime          time.Time
+	CreatedUserID        string
+	AcquiredTime         sql.NullTime
+	ScheduledDate        sqltypes.NullDate
+	ProjectID            sql.NullInt32
+}
+
+func (q *Queries) ListItemsLooseBetween(ctx context.Context, arg ListItemsLooseBetweenParams) ([]ListItemsLooseBetweenRow, error) {
+	rows, err := q.query(ctx, q.listItemsLooseBetweenStmt, listItemsLooseBetween, arg.CreatedTime, arg.CreatedTime_2, arg.ScopeID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []ListItemsLooseBetweenRow{}
+	for rows.Next() {
+		var i ListItemsLooseBetweenRow
+		if err := rows.Scan(
+			&i.ID,
+			&i.ScopeID,
+			&i.ProjectRequirementID,
+			&i.Name,
+			&i.Description,
+			&i.CreatedTime,
+			&i.CreatedUserID,
+			&i.AcquiredTime,
+			&i.ScheduledDate,
+			&i.ProjectID,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Close(); err != nil {
+		return nil, err
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const listItemsLooseBetweenNoScope = `-- name: ListItemsLooseBetweenNoScope :many
+SELECT i.id, i.scope_id, i.project_requirement_id, i.name, i.description, i.created_time, i.created_user_id, i.acquired_time, i.scheduled_date, pr.project_id FROM item i
+LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
+WHERE i.created_time >= ?
+  AND i.created_time < ?
+  AND i.scheduled_date IS NULL
+  AND i.acquired_time IS NULL
+`
+
+type ListItemsLooseBetweenNoScopeParams struct {
+	CreatedTime   time.Time
+	CreatedTime_2 time.Time
+}
+
+type ListItemsLooseBetweenNoScopeRow struct {
+	ID                   int
+	ScopeID              int
+	ProjectRequirementID sql.NullInt32
+	Name                 string
+	Description          string
+	CreatedTime          time.Time
+	CreatedUserID        string
+	AcquiredTime         sql.NullTime
+	ScheduledDate        sqltypes.NullDate
+	ProjectID            sql.NullInt32
+}
+
+func (q *Queries) ListItemsLooseBetweenNoScope(ctx context.Context, arg ListItemsLooseBetweenNoScopeParams) ([]ListItemsLooseBetweenNoScopeRow, error) {
+	rows, err := q.query(ctx, q.listItemsLooseBetweenNoScopeStmt, listItemsLooseBetweenNoScope, arg.CreatedTime, arg.CreatedTime_2)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []ListItemsLooseBetweenNoScopeRow{}
+	for rows.Next() {
+		var i ListItemsLooseBetweenNoScopeRow
+		if err := rows.Scan(
+			&i.ID,
+			&i.ScopeID,
+			&i.ProjectRequirementID,
+			&i.Name,
+			&i.Description,
+			&i.CreatedTime,
+			&i.CreatedUserID,
+			&i.AcquiredTime,
+			&i.ScheduledDate,
+			&i.ProjectID,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Close(); err != nil {
+		return nil, err
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const listItemsScheduledBetween = `-- name: ListItemsScheduledBetween :many
+SELECT i.id, i.scope_id, i.project_requirement_id, i.name, i.description, i.created_time, i.created_user_id, i.acquired_time, i.scheduled_date, pr.project_id FROM item i
+LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
+WHERE i.scheduled_date >= ?
+  AND i.scheduled_date <= ?
+  AND i.scope_id = ?
+ORDER BY scheduled_date, created_time
+`
+
+type ListItemsScheduledBetweenParams struct {
+	ScheduledDate   sqltypes.NullDate
+	ScheduledDate_2 sqltypes.NullDate
+	ScopeID         int
+}
+
+type ListItemsScheduledBetweenRow struct {
+	ID                   int
+	ScopeID              int
+	ProjectRequirementID sql.NullInt32
+	Name                 string
+	Description          string
+	CreatedTime          time.Time
+	CreatedUserID        string
+	AcquiredTime         sql.NullTime
+	ScheduledDate        sqltypes.NullDate
+	ProjectID            sql.NullInt32
+}
+
+func (q *Queries) ListItemsScheduledBetween(ctx context.Context, arg ListItemsScheduledBetweenParams) ([]ListItemsScheduledBetweenRow, error) {
+	rows, err := q.query(ctx, q.listItemsScheduledBetweenStmt, listItemsScheduledBetween, arg.ScheduledDate, arg.ScheduledDate_2, arg.ScopeID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []ListItemsScheduledBetweenRow{}
+	for rows.Next() {
+		var i ListItemsScheduledBetweenRow
+		if err := rows.Scan(
+			&i.ID,
+			&i.ScopeID,
+			&i.ProjectRequirementID,
+			&i.Name,
+			&i.Description,
+			&i.CreatedTime,
+			&i.CreatedUserID,
+			&i.AcquiredTime,
+			&i.ScheduledDate,
+			&i.ProjectID,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Close(); err != nil {
+		return nil, err
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const listItemsScheduledBetweenNoScope = `-- name: ListItemsScheduledBetweenNoScope :many
+SELECT i.id, i.scope_id, i.project_requirement_id, i.name, i.description, i.created_time, i.created_user_id, i.acquired_time, i.scheduled_date, pr.project_id FROM item i
+LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
+WHERE i.scheduled_date >= ?
+  AND i.scheduled_date < ?
+`
+
+type ListItemsScheduledBetweenNoScopeParams struct {
+	ScheduledDate   sqltypes.NullDate
+	ScheduledDate_2 sqltypes.NullDate
+}
+
+type ListItemsScheduledBetweenNoScopeRow struct {
+	ID                   int
+	ScopeID              int
+	ProjectRequirementID sql.NullInt32
+	Name                 string
+	Description          string
+	CreatedTime          time.Time
+	CreatedUserID        string
+	AcquiredTime         sql.NullTime
+	ScheduledDate        sqltypes.NullDate
+	ProjectID            sql.NullInt32
+}
+
+func (q *Queries) ListItemsScheduledBetweenNoScope(ctx context.Context, arg ListItemsScheduledBetweenNoScopeParams) ([]ListItemsScheduledBetweenNoScopeRow, error) {
+	rows, err := q.query(ctx, q.listItemsScheduledBetweenNoScopeStmt, listItemsScheduledBetweenNoScope, arg.ScheduledDate, arg.ScheduledDate_2)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []ListItemsScheduledBetweenNoScopeRow{}
+	for rows.Next() {
+		var i ListItemsScheduledBetweenNoScopeRow
+		if err := rows.Scan(
+			&i.ID,
+			&i.ScopeID,
+			&i.ProjectRequirementID,
+			&i.Name,
+			&i.Description,
+			&i.CreatedTime,
+			&i.CreatedUserID,
+			&i.AcquiredTime,
+			&i.ScheduledDate,
+			&i.ProjectID,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Close(); err != nil {
+		return nil, err
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const replaceItemStatProgress = `-- name: ReplaceItemStatProgress :exec
+REPLACE INTO item_stat_progress (item_id, stat_id, acquired, required)
+VALUES (?, ?, ?, ?)
+`
+
+type ReplaceItemStatProgressParams struct {
+	ItemID   int
+	StatID   int
+	Acquired int
+	Required int
+}
+
+func (q *Queries) ReplaceItemStatProgress(ctx context.Context, arg ReplaceItemStatProgressParams) error {
+	_, err := q.exec(ctx, q.replaceItemStatProgressStmt, replaceItemStatProgress,
+		arg.ItemID,
+		arg.StatID,
+		arg.Acquired,
+		arg.Required,
+	)
+	return err
+}
+
+const updateItem = `-- name: UpdateItem :exec
+UPDATE item
+SET project_requirement_id = ?,
+    name = ?,
+    description = ?,
+    acquired_time = ?,
+    scheduled_date = ?,
+    created_user_id = ?
+WHERE id = ?
+`
+
+type UpdateItemParams struct {
+	ProjectRequirementID sql.NullInt32
+	Name                 string
+	Description          string
+	AcquiredTime         sql.NullTime
+	ScheduledDate        sqltypes.NullDate
+	CreatedUserID        string
+	ID                   int
+}
+
+func (q *Queries) UpdateItem(ctx context.Context, arg UpdateItemParams) error {
+	_, err := q.exec(ctx, q.updateItemStmt, updateItem,
+		arg.ProjectRequirementID,
+		arg.Name,
+		arg.Description,
+		arg.AcquiredTime,
+		arg.ScheduledDate,
+		arg.CreatedUserID,
+		arg.ID,
+	)
+	return err
+}

internal/database/mysql/mysqlcore/models.go

@@ -0,0 +1,78 @@
+// Code generated by sqlc. DO NOT EDIT.
+// versions:
+//   sqlc v1.13.0
+
+package mysqlcore
+
+import (
+	"database/sql"
+	"time"
+
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/sqltypes"
+)
+
+type Item struct {
+	ID                   int
+	ScopeID              int
+	ProjectRequirementID sql.NullInt32
+	Name                 string
+	Description          string
+	CreatedTime          time.Time
+	CreatedUserID        string
+	AcquiredTime         sql.NullTime
+	ScheduledDate        sqltypes.NullDate
+}
+
+type ItemStatProgress struct {
+	ItemID   int
+	StatID   int
+	Acquired int
+	Required int
+}
+
+type Project struct {
+	ID          int
+	ScopeID     int
+	AuthorID    string
+	Name        string
+	Status      int
+	Description string
+	CreatedTime time.Time
+}
+
+type ProjectRequirement struct {
+	ID          int
+	ScopeID     int
+	ProjectID   int
+	Name        string
+	Status      int
+	Description string
+}
+
+type ProjectRequirementStat struct {
+	ProjectRequirementID int
+	StatID               int
+	Required             int
+}
+
+type Scope struct {
+	ID           int
+	Name         string
+	Abbreviation string
+}
+
+type ScopeMember struct {
+	ScopeID int
+	UserID  string
+	Name    string
+	Owner   bool
+}
+
+type Stat struct {
+	ID             int
+	ScopeID        int
+	Name           string
+	Description    string
+	Weight         float64
+	AllowedAmounts sqltypes.NullRawMessage
+}

internal/database/mysql/mysqlcore/package.go

@@ -0,0 +1,3 @@
+// Package mysqlcore contains generated code.
+package mysqlcore
+

internal/database/mysql/mysqlcore/project.sql.go

@@ -0,0 +1,340 @@
+// Code generated by sqlc. DO NOT EDIT.
+// versions:
+//   sqlc v1.13.0
+// source: project.sql
+
+package mysqlcore
+
+import (
+	"context"
+	"database/sql"
+	"time"
+)
+
+const deleteAllProjectRequirementStats = `-- name: DeleteAllProjectRequirementStats :exec
+DELETE FROM project_requirement_stat WHERE project_requirement_id = ?
+`
+
+func (q *Queries) DeleteAllProjectRequirementStats(ctx context.Context, projectRequirementID int) error {
+	_, err := q.exec(ctx, q.deleteAllProjectRequirementStatsStmt, deleteAllProjectRequirementStats, projectRequirementID)
+	return err
+}
+
+const deleteAllProjectRequirementStatsByStat = `-- name: DeleteAllProjectRequirementStatsByStat :exec
+DELETE FROM project_requirement_stat WHERE stat_id = ?
+`
+
+func (q *Queries) DeleteAllProjectRequirementStatsByStat(ctx context.Context, statID int) error {
+	_, err := q.exec(ctx, q.deleteAllProjectRequirementStatsByStatStmt, deleteAllProjectRequirementStatsByStat, statID)
+	return err
+}
+
+const deleteAllProjectRequirements = `-- name: DeleteAllProjectRequirements :exec
+DELETE FROM project_requirement WHERE project_id = ?
+`
+
+func (q *Queries) DeleteAllProjectRequirements(ctx context.Context, projectID int) error {
+	_, err := q.exec(ctx, q.deleteAllProjectRequirementsStmt, deleteAllProjectRequirements, projectID)
+	return err
+}
+
+const deleteProject = `-- name: DeleteProject :exec
+DELETE FROM project WHERE id = ?
+`
+
+func (q *Queries) DeleteProject(ctx context.Context, id int) error {
+	_, err := q.exec(ctx, q.deleteProjectStmt, deleteProject, id)
+	return err
+}
+
+const deleteProjectRequirement = `-- name: DeleteProjectRequirement :exec
+DELETE FROM project_requirement WHERE id = ?
+`
+
+func (q *Queries) DeleteProjectRequirement(ctx context.Context, id int) error {
+	_, err := q.exec(ctx, q.deleteProjectRequirementStmt, deleteProjectRequirement, id)
+	return err
+}
+
+const deleteProjectRequirementStat = `-- name: DeleteProjectRequirementStat :exec
+DELETE FROM project_requirement_stat WHERE project_requirement_id = ? AND stat_id = ?
+`
+
+type DeleteProjectRequirementStatParams struct {
+	ProjectRequirementID int
+	StatID               int
+}
+
+func (q *Queries) DeleteProjectRequirementStat(ctx context.Context, arg DeleteProjectRequirementStatParams) error {
+	_, err := q.exec(ctx, q.deleteProjectRequirementStatStmt, deleteProjectRequirementStat, arg.ProjectRequirementID, arg.StatID)
+	return err
+}
+
+const getProject = `-- name: GetProject :one
+SELECT id, scope_id, author_id, name, status, description, created_time FROM project WHERE id = ?
+`
+
+func (q *Queries) GetProject(ctx context.Context, id int) (Project, error) {
+	row := q.queryRow(ctx, q.getProjectStmt, getProject, id)
+	var i Project
+	err := row.Scan(
+		&i.ID,
+		&i.ScopeID,
+		&i.AuthorID,
+		&i.Name,
+		&i.Status,
+		&i.Description,
+		&i.CreatedTime,
+	)
+	return i, err
+}
+
+const getProjectRequirement = `-- name: GetProjectRequirement :one
+SELECT id, scope_id, project_id, name, status, description FROM project_requirement WHERE id = ?
+`
+
+func (q *Queries) GetProjectRequirement(ctx context.Context, id int) (ProjectRequirement, error) {
+	row := q.queryRow(ctx, q.getProjectRequirementStmt, getProjectRequirement, id)
+	var i ProjectRequirement
+	err := row.Scan(
+		&i.ID,
+		&i.ScopeID,
+		&i.ProjectID,
+		&i.Name,
+		&i.Status,
+		&i.Description,
+	)
+	return i, err
+}
+
+const insertProject = `-- name: InsertProject :execresult
+INSERT INTO project (scope_id, author_id, name, status, description, created_time)
+VALUES (?, ?, ?, ?, ?, ?)
+`
+
+type InsertProjectParams struct {
+	ScopeID     int
+	AuthorID    string
+	Name        string
+	Status      int
+	Description string
+	CreatedTime time.Time
+}
+
+func (q *Queries) InsertProject(ctx context.Context, arg InsertProjectParams) (sql.Result, error) {
+	return q.exec(ctx, q.insertProjectStmt, insertProject,
+		arg.ScopeID,
+		arg.AuthorID,
+		arg.Name,
+		arg.Status,
+		arg.Description,
+		arg.CreatedTime,
+	)
+}
+
+const insertProjectRequirement = `-- name: InsertProjectRequirement :execresult
+INSERT INTO project_requirement (scope_id, project_id, name, status, description)
+VALUES (?, ?, ?, ?, ?)
+`
+
+type InsertProjectRequirementParams struct {
+	ScopeID     int
+	ProjectID   int
+	Name        string
+	Status      int
+	Description string
+}
+
+func (q *Queries) InsertProjectRequirement(ctx context.Context, arg InsertProjectRequirementParams) (sql.Result, error) {
+	return q.exec(ctx, q.insertProjectRequirementStmt, insertProjectRequirement,
+		arg.ScopeID,
+		arg.ProjectID,
+		arg.Name,
+		arg.Status,
+		arg.Description,
+	)
+}
+
+const listProjectEntries = `-- name: ListProjectEntries :many
+SELECT id, name, status, created_time, author_id FROM project
+WHERE scope_id = ?
+ORDER BY status, created_time
+`
+
+type ListProjectEntriesRow struct {
+	ID          int
+	Name        string
+	Status      int
+	CreatedTime time.Time
+	AuthorID    string
+}
+
+func (q *Queries) ListProjectEntries(ctx context.Context, scopeID int) ([]ListProjectEntriesRow, error) {
+	rows, err := q.query(ctx, q.listProjectEntriesStmt, listProjectEntries, scopeID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []ListProjectEntriesRow{}
+	for rows.Next() {
+		var i ListProjectEntriesRow
+		if err := rows.Scan(
+			&i.ID,
+			&i.Name,
+			&i.Status,
+			&i.CreatedTime,
+			&i.AuthorID,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Close(); err != nil {
+		return nil, err
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const listProjectRequirementStats = `-- name: ListProjectRequirementStats :many
+SELECT prs.required, s.id, s.name, s.weight FROM project_requirement_stat prs
+RIGHT JOIN stat s ON s.id = prs.stat_id
+WHERE project_requirement_id = ?
+`
+
+type ListProjectRequirementStatsRow struct {
+	Required sql.NullInt32
+	ID       int
+	Name     string
+	Weight   float64
+}
+
+func (q *Queries) ListProjectRequirementStats(ctx context.Context, projectRequirementID int) ([]ListProjectRequirementStatsRow, error) {
+	rows, err := q.query(ctx, q.listProjectRequirementStatsStmt, listProjectRequirementStats, projectRequirementID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []ListProjectRequirementStatsRow{}
+	for rows.Next() {
+		var i ListProjectRequirementStatsRow
+		if err := rows.Scan(
+			&i.Required,
+			&i.ID,
+			&i.Name,
+			&i.Weight,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Close(); err != nil {
+		return nil, err
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const listProjectRequirementsByProjectID = `-- name: ListProjectRequirementsByProjectID :many
+SELECT id, scope_id, project_id, name, status, description FROM project_requirement WHERE project_id = ?
+`
+
+func (q *Queries) ListProjectRequirementsByProjectID(ctx context.Context, projectID int) ([]ProjectRequirement, error) {
+	rows, err := q.query(ctx, q.listProjectRequirementsByProjectIDStmt, listProjectRequirementsByProjectID, projectID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []ProjectRequirement{}
+	for rows.Next() {
+		var i ProjectRequirement
+		if err := rows.Scan(
+			&i.ID,
+			&i.ScopeID,
+			&i.ProjectID,
+			&i.Name,
+			&i.Status,
+			&i.Description,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Close(); err != nil {
+		return nil, err
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const replaceProjectRequirementStat = `-- name: ReplaceProjectRequirementStat :exec
+REPLACE INTO project_requirement_stat (project_requirement_id, stat_id, required)
+VALUES (?, ?, ?)
+`
+
+type ReplaceProjectRequirementStatParams struct {
+	ProjectRequirementID int
+	StatID               int
+	Required             int
+}
+
+func (q *Queries) ReplaceProjectRequirementStat(ctx context.Context, arg ReplaceProjectRequirementStatParams) error {
+	_, err := q.exec(ctx, q.replaceProjectRequirementStatStmt, replaceProjectRequirementStat, arg.ProjectRequirementID, arg.StatID, arg.Required)
+	return err
+}
+
+const updateProject = `-- name: UpdateProject :exec
+UPDATE project
+SET name = ?,
+    status = ?,
+    description = ?
+WHERE id = ?
+`
+
+type UpdateProjectParams struct {
+	Name        string
+	Status      int
+	Description string
+	ID          int
+}
+
+func (q *Queries) UpdateProject(ctx context.Context, arg UpdateProjectParams) error {
+	_, err := q.exec(ctx, q.updateProjectStmt, updateProject,
+		arg.Name,
+		arg.Status,
+		arg.Description,
+		arg.ID,
+	)
+	return err
+}
+
+const updateProjectRequirement = `-- name: UpdateProjectRequirement :exec
+UPDATE project_requirement
+SET name = ?,
+    status = ?,
+    description = ?
+WHERE id = ?
+`
+
+type UpdateProjectRequirementParams struct {
+	Name        string
+	Status      int
+	Description string
+	ID          int
+}
+
+func (q *Queries) UpdateProjectRequirement(ctx context.Context, arg UpdateProjectRequirementParams) error {
+	_, err := q.exec(ctx, q.updateProjectRequirementStmt, updateProjectRequirement,
+		arg.Name,
+		arg.Status,
+		arg.Description,
+		arg.ID,
+	)
+	return err
+}

internal/database/mysql/mysqlcore/scope.sql.go

@@ -0,0 +1,259 @@
+// Code generated by sqlc. DO NOT EDIT.
+// versions:
+//   sqlc v1.13.0
+// source: scope.sql
+
+package mysqlcore
+
+import (
+	"context"
+	"database/sql"
+)
+
+const deleteAllScopeMembers = `-- name: DeleteAllScopeMembers :exec
+DELETE FROM scope_member WHERE scope_id=?
+`
+
+func (q *Queries) DeleteAllScopeMembers(ctx context.Context, scopeID int) error {
+	_, err := q.exec(ctx, q.deleteAllScopeMembersStmt, deleteAllScopeMembers, scopeID)
+	return err
+}
+
+const deleteScope = `-- name: DeleteScope :exec
+DELETE FROM scope WHERE id=?
+`
+
+func (q *Queries) DeleteScope(ctx context.Context, id int) error {
+	_, err := q.exec(ctx, q.deleteScopeStmt, deleteScope, id)
+	return err
+}
+
+const deleteScopeMember = `-- name: DeleteScopeMember :exec
+DELETE FROM scope_member WHERE scope_id=? AND user_id=?
+`
+
+type DeleteScopeMemberParams struct {
+	ScopeID int
+	UserID  string
+}
+
+func (q *Queries) DeleteScopeMember(ctx context.Context, arg DeleteScopeMemberParams) error {
+	_, err := q.exec(ctx, q.deleteScopeMemberStmt, deleteScopeMember, arg.ScopeID, arg.UserID)
+	return err
+}
+
+const getScope = `-- name: GetScope :one
+SELECT id, name, abbreviation FROM scope
+WHERE id = ?
+`
+
+func (q *Queries) GetScope(ctx context.Context, id int) (Scope, error) {
+	row := q.queryRow(ctx, q.getScopeStmt, getScope, id)
+	var i Scope
+	err := row.Scan(&i.ID, &i.Name, &i.Abbreviation)
+	return i, err
+}
+
+const getScopeDisplayName = `-- name: GetScopeDisplayName :one
+SELECT name FROM scope_member
+WHERE user_id = ? AND scope_id = ?
+`
+
+type GetScopeDisplayNameParams struct {
+	UserID  string
+	ScopeID int
+}
+
+func (q *Queries) GetScopeDisplayName(ctx context.Context, arg GetScopeDisplayNameParams) (string, error) {
+	row := q.queryRow(ctx, q.getScopeDisplayNameStmt, getScopeDisplayName, arg.UserID, arg.ScopeID)
+	var name string
+	err := row.Scan(&name)
+	return name, err
+}
+
+const getScopeWithDisplayName = `-- name: GetScopeWithDisplayName :one
+SELECT id, scope.name, abbreviation, sm.name AS display_name FROM scope
+LEFT JOIN scope_member sm ON scope.id = sm.scope_id
+WHERE id = ? AND sm.user_id = ?
+`
+
+type GetScopeWithDisplayNameParams struct {
+	ID     int
+	UserID string
+}
+
+type GetScopeWithDisplayNameRow struct {
+	ID           int
+	Name         string
+	Abbreviation string
+	DisplayName  sql.NullString
+}
+
+func (q *Queries) GetScopeWithDisplayName(ctx context.Context, arg GetScopeWithDisplayNameParams) (GetScopeWithDisplayNameRow, error) {
+	row := q.queryRow(ctx, q.getScopeWithDisplayNameStmt, getScopeWithDisplayName, arg.ID, arg.UserID)
+	var i GetScopeWithDisplayNameRow
+	err := row.Scan(
+		&i.ID,
+		&i.Name,
+		&i.Abbreviation,
+		&i.DisplayName,
+	)
+	return i, err
+}
+
+const insertScope = `-- name: InsertScope :execresult
+INSERT INTO scope (id, name, abbreviation)
+VALUES (?, ?, ?)
+`
+
+type InsertScopeParams struct {
+	ID           int
+	Name         string
+	Abbreviation string
+}
+
+func (q *Queries) InsertScope(ctx context.Context, arg InsertScopeParams) (sql.Result, error) {
+	return q.exec(ctx, q.insertScopeStmt, insertScope, arg.ID, arg.Name, arg.Abbreviation)
+}
+
+const listScopeMembers = `-- name: ListScopeMembers :many
+SELECT user_id, name, owner FROM scope_member
+WHERE scope_id = ?
+ORDER BY name
+`
+
+type ListScopeMembersRow struct {
+	UserID string
+	Name   string
+	Owner  bool
+}
+
+func (q *Queries) ListScopeMembers(ctx context.Context, scopeID int) ([]ListScopeMembersRow, error) {
+	rows, err := q.query(ctx, q.listScopeMembersStmt, listScopeMembers, scopeID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []ListScopeMembersRow{}
+	for rows.Next() {
+		var i ListScopeMembersRow
+		if err := rows.Scan(&i.UserID, &i.Name, &i.Owner); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Close(); err != nil {
+		return nil, err
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const listScopes = `-- name: ListScopes :many
+SELECT id, name, abbreviation FROM scope
+ORDER BY name
+`
+
+func (q *Queries) ListScopes(ctx context.Context) ([]Scope, error) {
+	rows, err := q.query(ctx, q.listScopesStmt, listScopes)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []Scope{}
+	for rows.Next() {
+		var i Scope
+		if err := rows.Scan(&i.ID, &i.Name, &i.Abbreviation); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Close(); err != nil {
+		return nil, err
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const listScopesByUser = `-- name: ListScopesByUser :many
+SELECT id, s.name, abbreviation, sm.name as display_name FROM scope_member sm
+RIGHT JOIN scope s on s.id = sm.scope_id
+WHERE sm.user_id = ?
+ORDER BY s.name
+`
+
+type ListScopesByUserRow struct {
+	ID           int
+	Name         string
+	Abbreviation string
+	DisplayName  sql.NullString
+}
+
+func (q *Queries) ListScopesByUser(ctx context.Context, userID string) ([]ListScopesByUserRow, error) {
+	rows, err := q.query(ctx, q.listScopesByUserStmt, listScopesByUser, userID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []ListScopesByUserRow{}
+	for rows.Next() {
+		var i ListScopesByUserRow
+		if err := rows.Scan(
+			&i.ID,
+			&i.Name,
+			&i.Abbreviation,
+			&i.DisplayName,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Close(); err != nil {
+		return nil, err
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const updateScope = `-- name: UpdateScope :exec
+UPDATE scope SET name = ?, abbreviation = ? WHERE id = ?
+`
+
+type UpdateScopeParams struct {
+	Name         string
+	Abbreviation string
+	ID           int
+}
+
+func (q *Queries) UpdateScope(ctx context.Context, arg UpdateScopeParams) error {
+	_, err := q.exec(ctx, q.updateScopeStmt, updateScope, arg.Name, arg.Abbreviation, arg.ID)
+	return err
+}
+
+const updateScopeMember = `-- name: UpdateScopeMember :exec
+REPLACE INTO scope_member (scope_id, user_id, name, owner)
+VALUES (?, ?, ?, ?)
+`
+
+type UpdateScopeMemberParams struct {
+	ScopeID int
+	UserID  string
+	Name    string
+	Owner   bool
+}
+
+func (q *Queries) UpdateScopeMember(ctx context.Context, arg UpdateScopeMemberParams) error {
+	_, err := q.exec(ctx, q.updateScopeMemberStmt, updateScopeMember,
+		arg.ScopeID,
+		arg.UserID,
+		arg.Name,
+		arg.Owner,
+	)
+	return err
+}

internal/database/mysql/mysqlcore/stats.sql.go

@@ -0,0 +1,153 @@
+// Code generated by sqlc. DO NOT EDIT.
+// versions:
+//   sqlc v1.13.0
+// source: stats.sql
+
+package mysqlcore
+
+import (
+	"context"
+	"database/sql"
+
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/sqltypes"
+)
+
+const deleteStat = `-- name: DeleteStat :exec
+DELETE FROM stat WHERE id = ? AND scope_id = ?
+`
+
+type DeleteStatParams struct {
+	ID      int
+	ScopeID int
+}
+
+func (q *Queries) DeleteStat(ctx context.Context, arg DeleteStatParams) error {
+	_, err := q.exec(ctx, q.deleteStatStmt, deleteStat, arg.ID, arg.ScopeID)
+	return err
+}
+
+const getStat = `-- name: GetStat :one
+SELECT id, name, description, weight, allowed_amounts FROM stat
+WHERE scope_id = ? AND id = ?
+`
+
+type GetStatParams struct {
+	ScopeID int
+	ID      int
+}
+
+type GetStatRow struct {
+	ID             int
+	Name           string
+	Description    string
+	Weight         float64
+	AllowedAmounts sqltypes.NullRawMessage
+}
+
+func (q *Queries) GetStat(ctx context.Context, arg GetStatParams) (GetStatRow, error) {
+	row := q.queryRow(ctx, q.getStatStmt, getStat, arg.ScopeID, arg.ID)
+	var i GetStatRow
+	err := row.Scan(
+		&i.ID,
+		&i.Name,
+		&i.Description,
+		&i.Weight,
+		&i.AllowedAmounts,
+	)
+	return i, err
+}
+
+const insertStat = `-- name: InsertStat :execresult
+INSERT INTO stat (scope_id, name, description, weight, allowed_amounts)
+VALUES (?, ?, ?, ?, ?)
+`
+
+type InsertStatParams struct {
+	ScopeID        int
+	Name           string
+	Description    string
+	Weight         float64
+	AllowedAmounts sqltypes.NullRawMessage
+}
+
+func (q *Queries) InsertStat(ctx context.Context, arg InsertStatParams) (sql.Result, error) {
+	return q.exec(ctx, q.insertStatStmt, insertStat,
+		arg.ScopeID,
+		arg.Name,
+		arg.Description,
+		arg.Weight,
+		arg.AllowedAmounts,
+	)
+}
+
+const listStats = `-- name: ListStats :many
+SELECT id, name, description, weight, allowed_amounts FROM stat
+WHERE scope_id = ?
+`
+
+type ListStatsRow struct {
+	ID             int
+	Name           string
+	Description    string
+	Weight         float64
+	AllowedAmounts sqltypes.NullRawMessage
+}
+
+func (q *Queries) ListStats(ctx context.Context, scopeID int) ([]ListStatsRow, error) {
+	rows, err := q.query(ctx, q.listStatsStmt, listStats, scopeID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	items := []ListStatsRow{}
+	for rows.Next() {
+		var i ListStatsRow
+		if err := rows.Scan(
+			&i.ID,
+			&i.Name,
+			&i.Description,
+			&i.Weight,
+			&i.AllowedAmounts,
+		); err != nil {
+			return nil, err
+		}
+		items = append(items, i)
+	}
+	if err := rows.Close(); err != nil {
+		return nil, err
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	return items, nil
+}
+
+const updateStat = `-- name: UpdateStat :exec
+UPDATE stat SET
+    name = ?,
+    description = ?,
+    weight = ?,
+    allowed_amounts = ?
+WHERE id = ? AND scope_id = ?
+`
+
+type UpdateStatParams struct {
+	Name           string
+	Description    string
+	Weight         float64
+	AllowedAmounts sqltypes.NullRawMessage
+	ID             int
+	ScopeID        int
+}
+
+func (q *Queries) UpdateStat(ctx context.Context, arg UpdateStatParams) error {
+	_, err := q.exec(ctx, q.updateStatStmt, updateStat,
+		arg.Name,
+		arg.Description,
+		arg.Weight,
+		arg.AllowedAmounts,
+		arg.ID,
+		arg.ScopeID,
+	)
+	return err
+}

internal/database/mysql/project.go

@@ -0,0 +1,340 @@
+package mysql
+
+import (
+	"context"
+	"database/sql"
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/database/mysql/mysqlcore"
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/models"
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/slerrors"
+	"golang.org/x/sync/errgroup"
+)
+
+type projectRepository struct {
+	db      *sql.DB
+	q       *mysqlcore.Queries
+	items   *itemRepository
+	scopeID int
+}
+
+func (r *projectRepository) Find(ctx context.Context, id int) (*models.Project, error) {
+	row, err := r.q.GetProject(ctx, id)
+	if err == sql.ErrNoRows || row.ScopeID != r.scopeID {
+		return nil, slerrors.NotFound("Project")
+	} else if err != nil {
+		return nil, err
+	}
+
+	project := models.Project{
+		ProjectEntry: models.ProjectEntry{
+			ID:          row.ID,
+			OwnerID:     row.AuthorID,
+			CreatedTime: row.CreatedTime,
+			Name:        row.Name,
+			Status:      models.Status(row.Status),
+		},
+		Description:  row.Description,
+		Requirements: []models.ProjectRequirement{},
+	}
+
+	reqs, err := r.q.ListProjectRequirementsByProjectID(ctx, id)
+	if err != nil && err != sql.ErrNoRows {
+		return nil, err
+	}
+	itemRows, err := r.q.ListItemsByProject(ctx, id)
+	if err != nil && err != sql.ErrNoRows {
+		return nil, err
+	}
+	items := make([]models.Item, 0, len(itemRows))
+	for _, itemRow := range itemRows {
+		item := r.items.resToItem(mysqlcore.ListItemsAcquiredBetweenRow(itemRow))
+		items = append(items, item)
+	}
+
+	err = r.items.fillStats(ctx, items)
+	if err != nil {
+		return nil, err
+	}
+
+	eg, ctx := errgroup.WithContext(ctx)
+
+	for i := range reqs {
+		project.Requirements = append(project.Requirements, models.ProjectRequirement{
+			ID:          reqs[i].ID,
+			Name:        reqs[i].Name,
+			Description: reqs[i].Description,
+			Status:      models.Status(reqs[i].Status),
+			Stats:       []models.StatProgressEntry{},
+			Items:       nil,
+		})
+		requirement := &project.Requirements[len(project.Requirements)-1]
+		for _, item := range items {
+			if *item.ProjectRequirementID == requirement.ID {
+				requirement.Items = append(requirement.Items, item)
+			}
+		}
+
+		eg.Go(func() error {
+			stats, err := r.q.ListProjectRequirementStats(ctx, requirement.ID)
+			if err != nil && err != sql.ErrNoRows {
+				return err
+			}
+
+			for _, statRow := range stats {
+				stat := models.StatProgressEntry{
+					StatEntry: models.StatEntry{
+						ID:     statRow.ID,
+						Name:   statRow.Name,
+						Weight: statRow.Weight,
+					},
+					Acquired: 0,
+					Required: int(statRow.Required.Int32),
+				}
+
+				for _, item := range requirement.Items {
+					for _, stat2 := range item.Stats {
+						if stat2.ID == stat.ID {
+							stat.Acquired += stat2.Acquired
+						}
+					}
+				}
+
+				requirement.Stats = append(requirement.Stats, stat)
+			}
+
+			return nil
+		})
+	}
+
+	err = eg.Wait()
+	if err != nil {
+		return nil, err
+	}
+
+	return &project, nil
+}
+
+func (r *projectRepository) List(ctx context.Context) ([]models.ProjectEntry, error) {
+	rows, err := r.q.ListProjectEntries(ctx, r.scopeID)
+	if err != nil && err != sql.ErrNoRows {
+		return nil, err
+	}
+
+	projects := make([]models.ProjectEntry, 0, len(rows))
+	for _, row := range rows {
+		projects = append(projects, models.ProjectEntry{
+			ID:          row.ID,
+			OwnerID:     row.AuthorID,
+			CreatedTime: row.CreatedTime,
+			Name:        row.Name,
+			Status:      models.Status(row.Status),
+		})
+	}
+
+	return projects, nil
+}
+
+func (r *projectRepository) Create(ctx context.Context, project models.Project) (*models.Project, error) {
+	res, err := r.q.InsertProject(ctx, mysqlcore.InsertProjectParams{
+		ScopeID:     r.scopeID,
+		AuthorID:    project.OwnerID,
+		Name:        project.Name,
+		Status:      int(project.Status),
+		Description: project.Description,
+		CreatedTime: project.CreatedTime,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	id, err := res.LastInsertId()
+	if err != nil {
+		return nil, err
+	}
+
+	return r.Find(ctx, int(id))
+}
+
+func (r *projectRepository) Update(ctx context.Context, project models.Project, update models.ProjectUpdate) (*models.Project, error) {
+	project.Update(update)
+
+	err := r.q.UpdateProject(ctx, mysqlcore.UpdateProjectParams{
+		Name:        project.Name,
+		Status:      int(project.Status),
+		Description: project.Description,
+		ID:          project.ID,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return r.Find(ctx, project.ID)
+}
+
+func (r *projectRepository) Delete(ctx context.Context, project models.ProjectEntry, deleteItems bool) error {
+	tx, err := r.db.BeginTx(ctx, nil)
+	if err != nil {
+		return err
+	}
+	defer tx.Rollback()
+	q := r.q.WithTx(tx)
+
+	err = q.DeleteProject(ctx, project.ID)
+	if err != nil {
+		return err
+	}
+
+	if deleteItems {
+		reqs, err := q.ListProjectRequirementsByProjectID(ctx, project.ID)
+		if err != nil {
+			return err
+		}
+
+		for _, req := range reqs {
+			err = q.DeleteItemForRequirement(ctx, sql.NullInt32{Valid: true, Int32: int32(req.ID)})
+			if err != nil {
+				return err
+			}
+
+			err = q.DeleteAllProjectRequirementStats(ctx, req.ID)
+			if err != nil {
+				return err
+			}
+		}
+	} else {
+		err = q.ClearItemProjectRequirementByProjectID(ctx, project.ID)
+		if err != nil {
+			return err
+		}
+	}
+
+	return tx.Commit()
+}
+
+func (r *projectRepository) AddRequirement(ctx context.Context, project models.ProjectEntry, requirement models.ProjectRequirement) (*models.Project, error) {
+	tx, err := r.db.BeginTx(ctx, nil)
+	if err != nil {
+		return nil, err
+	}
+	defer tx.Rollback()
+	q := r.q.WithTx(tx)
+
+	res, err := q.InsertProjectRequirement(ctx, mysqlcore.InsertProjectRequirementParams{
+		ScopeID:     r.scopeID,
+		ProjectID:   project.ID,
+		Name:        requirement.Name,
+		Status:      int(requirement.Status),
+		Description: requirement.Description,
+	})
+	if err != nil {
+		return nil, err
+	}
+	id, err := res.LastInsertId()
+	if err != nil {
+		return nil, err
+	}
+
+	for _, stat := range requirement.Stats {
+		err = q.ReplaceProjectRequirementStat(ctx, mysqlcore.ReplaceProjectRequirementStatParams{
+			ProjectRequirementID: int(id),
+			StatID:               stat.ID,
+			Required:             stat.Required,
+		})
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	err = tx.Commit()
+	if err != nil {
+		return nil, err
+	}
+
+	return r.Find(ctx, project.ID)
+}
+
+func (r *projectRepository) UpdateRequirement(ctx context.Context, project models.ProjectEntry, requirement models.ProjectRequirement, update models.ProjectRequirementUpdate) (*models.Project, error) {
+	tx, err := r.db.BeginTx(ctx, nil)
+	if err != nil {
+		return nil, err
+	}
+	defer tx.Rollback()
+	q := r.q.WithTx(tx)
+
+	requirement.Update(update)
+	err = q.UpdateProjectRequirement(ctx, mysqlcore.UpdateProjectRequirementParams{
+		Name:        requirement.Name,
+		Status:      int(requirement.Status),
+		Description: requirement.Description,
+		ID:          requirement.ID,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	for _, stat := range requirement.Stats {
+		if stat.Required < 0 {
+			err = q.DeleteProjectRequirementStat(ctx, mysqlcore.DeleteProjectRequirementStatParams{
+				ProjectRequirementID: requirement.ID,
+				StatID:               stat.ID,
+			})
+		} else {
+			err = q.ReplaceProjectRequirementStat(ctx, mysqlcore.ReplaceProjectRequirementStatParams{
+				ProjectRequirementID: requirement.ID,
+				StatID:               stat.ID,
+				Required:             stat.Required,
+			})
+		}
+
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	err = tx.Commit()
+	if err != nil {
+		return nil, err
+	}
+
+	return r.Find(ctx, project.ID)
+}
+
+func (r *projectRepository) DeleteRequirement(ctx context.Context, project models.ProjectEntry, requirement models.ProjectRequirement, deleteItems bool) (*models.Project, error) {
+	tx, err := r.db.BeginTx(ctx, nil)
+	if err != nil {
+		return nil, err
+	}
+	defer tx.Rollback()
+	q := r.q.WithTx(tx)
+
+	err = q.DeleteProjectRequirement(ctx, requirement.ID)
+	if err != nil {
+		if err == sql.ErrNoRows {
+			return nil, slerrors.NotFound("Project requirement")
+		}
+		return nil, err
+	}
+
+	if deleteItems {
+		err = q.DeleteItemForRequirement(ctx, sql.NullInt32{Valid: true, Int32: int32(requirement.ID)})
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		err = q.ClearItemProjectRequirement(ctx, sql.NullInt32{Valid: true, Int32: int32(requirement.ID)})
+		if err != nil {
+			return nil, err
+		}
+
+		err = q.DeleteAllProjectRequirementStats(ctx, requirement.ID)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	err = tx.Commit()
+	if err != nil {
+		return nil, err
+	}
+
+	return r.Find(ctx, project.ID)
+}

internal/database/mysql/queries/item.sql

@@ -0,0 +1,125 @@
+-- name: GetItem :one
+SELECT i.*, pr.project_id FROM item i
+LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
+WHERE i.id = ?;
+
+-- name: ListItemsByProject :many
+SELECT i.*, pr.project_id FROM item i
+LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
+WHERE pr.project_id = ?;
+
+-- name: ListItemsAcquiredBetween :many
+SELECT i.*, pr.project_id FROM item i
+LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
+WHERE i.acquired_time >= ?
+  AND i.acquired_time <= ?
+  AND i.scope_id = ?
+ORDER BY acquired_time DESC, created_time DESC;
+
+-- name: ListItemsScheduledBetween :many
+SELECT i.*, pr.project_id FROM item i
+LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
+WHERE i.scheduled_date >= ?
+  AND i.scheduled_date <= ?
+  AND i.scope_id = ?
+ORDER BY scheduled_date, created_time;
+
+-- name: ListItemsCreatedBetween :many
+SELECT i.*, pr.project_id FROM item i
+LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
+WHERE i.created_time >= ?
+  AND i.created_time <= ?
+  AND i.scope_id = ?
+ORDER BY created_time DESC;
+
+-- name: ListItemsLooseBetween :many
+SELECT i.*, pr.project_id FROM item i
+LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
+WHERE i.created_time >= ?
+  AND i.created_time <= ?
+  AND i.scope_id = ?
+  AND i.scheduled_date IS NULL
+  AND i.acquired_time IS NULL
+  AND i.project_requirement_id IS NULL
+ORDER BY created_time DESC;
+
+-- name: ListItemsScheduledBetweenNoScope :many
+SELECT i.*, pr.project_id FROM item i
+LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
+WHERE i.scheduled_date >= ?
+  AND i.scheduled_date < ?;
+
+-- name: ListItemsCreatedBetweenNoScope :many
+SELECT i.*, pr.project_id FROM item i
+LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
+WHERE i.created_time >= ?
+  AND i.created_time < ?;
+
+-- name: ListItemsLooseBetweenNoScope :many
+SELECT i.*, pr.project_id FROM item i
+LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
+WHERE i.created_time >= ?
+  AND i.created_time < ?
+  AND i.scheduled_date IS NULL
+  AND i.acquired_time IS NULL;
+
+-- name: GetItemStatProgressBetween :one
+SELECT s.id, s.name, s.weight, SUM(isp.acquired), SUM(isp.required) FROM item i
+LEFT JOIN item_stat_progress isp on i.id = isp.item_id
+LEFT JOIN stat s on isp.stat_id = s.id
+WHERE i.acquired_time >= ?
+  AND i.acquired_time < ?
+  AND i.scope_id = ?
+GROUP BY stat_id;
+
+-- name: ListItemStatProgress :many
+SELECT isp.required, isp.acquired, s.id, s.name, s.weight FROM item_stat_progress isp
+LEFT JOIN stat s ON s.id = isp.stat_id
+WHERE item_id = ?;
+
+-- name: ListItemStatProgressMulti :many
+SELECT isp.item_id, isp.required, isp.acquired, s.id, s.name, s.weight FROM item_stat_progress isp
+LEFT JOIN stat s ON s.id = isp.stat_id
+WHERE item_id IN (?, ?, ?, ?, ?, ?, ?, ?);
+
+-- name: InsertItem :execresult
+INSERT INTO item (scope_id, project_requirement_id, name, description, created_time, created_user_id, acquired_time, scheduled_date)
+VALUES (?, ?, ?, ?, ?, ?, ?, ?);
+
+-- name: UpdateItem :exec
+UPDATE item
+SET project_requirement_id = ?,
+    name = ?,
+    description = ?,
+    acquired_time = ?,
+    scheduled_date = ?,
+    created_user_id = ?
+WHERE id = ?;
+
+-- name: DeleteItem :exec
+DELETE FROM item WHERE id = ?;
+
+-- name: DeleteItemForRequirement :exec
+DELETE FROM item WHERE project_requirement_id = ?;
+
+-- name: ClearItemProjectRequirement :exec
+UPDATE item SET project_requirement_id = NULL WHERE project_requirement_id = ?;
+
+-- name: ClearItemProjectRequirementByProjectID :exec
+UPDATE item i
+LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
+SET i.project_requirement_id = NULL
+WHERE pr.project_id = ?;
+
+-- name: ReplaceItemStatProgress :exec
+REPLACE INTO item_stat_progress (item_id, stat_id, acquired, required)
+VALUES (?, ?, ?, ?);
+
+-- name: DeleteItemStatProgress :exec
+DELETE FROM item_stat_progress WHERE item_id = ? AND stat_id = ?;
+
+-- name: ClearItemStatProgress :exec
+DELETE FROM item_stat_progress WHERE item_id = ?;
+
+-- name: CLearItemStatProgressByStat :exec
+DELETE FROM item_stat_progress WHERE stat_id = ?;

internal/database/mysql/queries/project.sql

@@ -0,0 +1,63 @@
+-- name: ListProjectEntries :many
+SELECT id, name, status, created_time, author_id FROM project
+WHERE scope_id = ?
+ORDER BY status, created_time;
+
+-- name: GetProject :one
+SELECT * FROM project WHERE id = ?;
+
+-- name: GetProjectRequirement :one
+SELECT * FROM project_requirement WHERE id = ?;
+
+-- name: ListProjectRequirementsByProjectID :many
+SELECT * FROM project_requirement WHERE project_id = ?;
+
+-- name: ListProjectRequirementStats :many
+SELECT prs.required, s.id, s.name, s.weight FROM project_requirement_stat prs
+RIGHT JOIN stat s ON s.id = prs.stat_id
+WHERE project_requirement_id = ?;
+
+-- name: InsertProject :execresult
+INSERT INTO project (scope_id, author_id, name, status, description, created_time)
+VALUES (?, ?, ?, ?, ?, ?);
+
+-- name: UpdateProject :exec
+UPDATE project
+SET name = ?,
+    status = ?,
+    description = ?
+WHERE id = ?;
+
+-- name: DeleteProject :exec
+DELETE FROM project WHERE id = ?;
+
+-- name: InsertProjectRequirement :execresult
+INSERT INTO project_requirement (scope_id, project_id, name, status, description)
+VALUES (?, ?, ?, ?, ?);
+
+-- name: UpdateProjectRequirement :exec
+UPDATE project_requirement
+SET name = ?,
+    status = ?,
+    description = ?
+WHERE id = ?;
+
+-- name: DeleteProjectRequirement :exec
+DELETE FROM project_requirement WHERE id = ?;
+
+-- name: DeleteAllProjectRequirements :exec
+DELETE FROM project_requirement WHERE project_id = ?;
+
+-- name: ReplaceProjectRequirementStat :exec
+REPLACE INTO project_requirement_stat (project_requirement_id, stat_id, required)
+VALUES (?, ?, ?);
+
+-- name: DeleteProjectRequirementStat :exec
+DELETE FROM project_requirement_stat WHERE project_requirement_id = ? AND stat_id = ?;
+
+-- name: DeleteAllProjectRequirementStats :exec
+DELETE FROM project_requirement_stat WHERE project_requirement_id = ?;
+
+-- name: DeleteAllProjectRequirementStatsByStat :exec
+DELETE FROM project_requirement_stat WHERE stat_id = ?;
+

internal/database/mysql/queries/scope.sql

@@ -0,0 +1,47 @@
+-- name: GetScope :one
+SELECT id, name, abbreviation FROM scope
+WHERE id = ?;
+
+-- name: ListScopes :many
+SELECT id, name, abbreviation FROM scope
+ORDER BY name;
+
+-- name: ListScopesByUser :many
+SELECT id, s.name, abbreviation, sm.name as display_name FROM scope_member sm
+RIGHT JOIN scope s on s.id = sm.scope_id
+WHERE sm.user_id = ?
+ORDER BY s.name;
+
+-- name: ListScopeMembers :many
+SELECT user_id, name, owner FROM scope_member
+WHERE scope_id = ?
+ORDER BY name;
+
+-- name: GetScopeWithDisplayName :one
+SELECT id, scope.name, abbreviation, sm.name AS display_name FROM scope
+LEFT JOIN scope_member sm ON scope.id = sm.scope_id
+WHERE id = ? AND sm.user_id = ?;
+
+-- name: GetScopeDisplayName :one
+SELECT name FROM scope_member
+WHERE user_id = ? AND scope_id = ?;
+
+-- name: InsertScope :execresult
+INSERT INTO scope (id, name, abbreviation)
+VALUES (?, ?, ?);
+
+-- name: UpdateScope :exec
+UPDATE scope SET name = ?, abbreviation = ? WHERE id = ?;
+
+-- name: UpdateScopeMember :exec
+REPLACE INTO scope_member (scope_id, user_id, name, owner)
+VALUES (?, ?, ?, ?);
+
+-- name: DeleteScopeMember :exec
+DELETE FROM scope_member WHERE scope_id=? AND user_id=?;
+
+-- name: DeleteAllScopeMembers :exec
+DELETE FROM scope_member WHERE scope_id=?;
+
+-- name: DeleteScope :exec
+DELETE FROM scope WHERE id=?;

internal/database/mysql/queries/stats.sql

@@ -0,0 +1,22 @@
+-- name: ListStats :many
+SELECT id, name, description, weight, allowed_amounts FROM stat
+WHERE scope_id = ?;
+
+-- name: GetStat :one
+SELECT id, name, description, weight, allowed_amounts FROM stat
+WHERE scope_id = ? AND id = ?;
+
+-- name: InsertStat :execresult
+INSERT INTO stat (scope_id, name, description, weight, allowed_amounts)
+VALUES (?, ?, ?, ?, ?);
+
+-- name: UpdateStat :exec
+UPDATE stat SET
+    name = ?,
+    description = ?,
+    weight = ?,
+    allowed_amounts = ?
+WHERE id = ? AND scope_id = ?;
+
+-- name: DeleteStat :exec
+DELETE FROM stat WHERE id = ? AND scope_id = ?;

internal/database/mysql/scopes.go

@@ -0,0 +1,278 @@
+package mysql
+
+import (
+	"context"
+	"database/sql"
+	"encoding/json"
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/database/mysql/mysqlcore"
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/models"
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/slerrors"
+	"golang.org/x/sync/errgroup"
+	"sort"
+)
+
+type scopeRepository struct {
+	db *sql.DB
+	q  *mysqlcore.Queries
+}
+
+func (r *scopeRepository) Find(ctx context.Context, id int, full bool) (*models.Scope, error) {
+	scope, err := r.q.GetScope(ctx, id)
+	if err != nil {
+		if err == sql.ErrNoRows {
+			return nil, slerrors.NotFound("Scope")
+		}
+
+		return nil, err
+	}
+
+	res := &models.Scope{
+		ScopeEntry: models.ScopeEntry{
+			ID:           scope.ID,
+			Name:         scope.Name,
+			Abbreviation: scope.Abbreviation,
+		},
+		Members:      []models.ScopeMember{},
+		Projects:     []models.ProjectEntry{},
+		Stats:        []models.Stat{},
+		StatusLabels: make(map[models.Status]string),
+	}
+
+	eg, ctx := errgroup.WithContext(ctx)
+
+	if full {
+		eg.Go(func() error {
+			projects, err := r.q.ListProjectEntries(ctx, id)
+			if err != nil && err != sql.ErrNoRows {
+				return err
+			}
+
+			for _, project := range projects {
+				res.Projects = append(res.Projects, models.ProjectEntry{
+					ID:          project.ID,
+					OwnerID:     project.AuthorID,
+					CreatedTime: project.CreatedTime,
+					Name:        project.Name,
+					Status:      models.Status(project.Status),
+				})
+			}
+
+			return nil
+		})
+
+		eg.Go(func() error {
+			stats, err := r.q.ListStats(ctx, id)
+			if err != nil && err != sql.ErrNoRows {
+				return err
+			}
+
+			for _, stat := range stats {
+				var amounts map[string]int
+				if stat.AllowedAmounts.Valid {
+					amounts = make(map[string]int)
+					err := json.Unmarshal(stat.AllowedAmounts.RawMessage, &amounts)
+					if err != nil {
+						return err
+					}
+				}
+
+				res.Stats = append(res.Stats, models.Stat{
+					StatEntry: models.StatEntry{
+						ID:     stat.ID,
+						Name:   stat.Name,
+						Weight: stat.Weight,
+					},
+					Description:    stat.Description,
+					AllowedAmounts: amounts,
+				})
+			}
+
+			return nil
+		})
+	}
+
+	eg.Go(func() error {
+		members, err := r.q.ListScopeMembers(ctx, id)
+		if err != nil && err != sql.ErrNoRows {
+			return err
+		}
+
+		for _, member := range members {
+			res.Members = append(res.Members, models.ScopeMember{
+				ID:    member.UserID,
+				Name:  member.Name,
+				Owner: member.Owner,
+			})
+		}
+
+		return nil
+	})
+
+	err = eg.Wait()
+	if err != nil {
+		return nil, err
+	}
+
+	return res, nil
+}
+
+func (r *scopeRepository) List(ctx context.Context) ([]models.ScopeEntry, error) {
+	scopes, err := r.q.ListScopes(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	res := make([]models.ScopeEntry, 0, len(scopes))
+	for _, scope := range scopes {
+		res = append(res, models.ScopeEntry{
+			ID:           scope.ID,
+			Name:         scope.Name,
+			Abbreviation: scope.Abbreviation,
+		})
+	}
+
+	return res, nil
+}
+
+func (r *scopeRepository) ListByUser(ctx context.Context, userID string) ([]models.ScopeEntry, error) {
+	scopes, err := r.q.ListScopesByUser(ctx, userID)
+	if err != nil {
+		return nil, err
+	}
+
+	res := make([]models.ScopeEntry, 0, len(scopes))
+	for _, scope := range scopes {
+		res = append(res, models.ScopeEntry{
+			ID:           scope.ID,
+			Name:         scope.Name,
+			Abbreviation: scope.Abbreviation,
+		})
+	}
+
+	return res, nil
+}
+
+func (r *scopeRepository) Create(ctx context.Context, scope models.ScopeEntry, owner models.ScopeMember) (*models.Scope, error) {
+	tx, err := r.db.BeginTx(ctx, nil)
+	if err != nil {
+		return nil, err
+	}
+	defer tx.Rollback()
+
+	q := r.q.WithTx(tx)
+	res, err := q.InsertScope(ctx, mysqlcore.InsertScopeParams(scope))
+	if err != nil {
+		return nil, err
+	}
+	id, err := res.LastInsertId()
+	if err != nil {
+		return nil, err
+	}
+
+	err = q.UpdateScopeMember(ctx, mysqlcore.UpdateScopeMemberParams{
+		ScopeID: int(id),
+		UserID:  owner.ID,
+		Name:    owner.Name,
+		Owner:   true,
+	})
+
+	err = tx.Commit()
+	if err != nil {
+		return nil, err
+	}
+
+	return &models.Scope{
+		ScopeEntry: models.ScopeEntry{
+			ID:           int(id),
+			Name:         scope.Name,
+			Abbreviation: scope.Abbreviation,
+		},
+		DisplayName: owner.Name,
+		Members: []models.ScopeMember{
+			{
+				ID:    owner.ID,
+				Name:  owner.Name,
+				Owner: true,
+			},
+		},
+		Projects: []models.ProjectEntry{},
+		Stats:    []models.Stat{},
+	}, nil
+}
+
+func (r *scopeRepository) Update(ctx context.Context, scope models.ScopeEntry) error {
+	return mysqlcore.New(r.db).UpdateScope(ctx, mysqlcore.UpdateScopeParams{
+		Name:         scope.Name,
+		Abbreviation: scope.Abbreviation,
+		ID:           scope.ID,
+	})
+}
+
+func (r *scopeRepository) Delete(ctx context.Context, scope models.Scope) error {
+	tx, err := r.db.BeginTx(ctx, nil)
+	if err != nil {
+		return err
+	}
+	defer tx.Rollback()
+
+	q := r.q.WithTx(tx)
+	err = q.DeleteAllScopeMembers(ctx, scope.ID)
+	if err != nil {
+		return err
+	}
+	err = q.DeleteScope(ctx, scope.ID)
+	if err != nil {
+		return err
+	}
+
+	return tx.Commit()
+}
+
+func (r *scopeRepository) UpdateMember(ctx context.Context, scope models.Scope, member models.ScopeMember) (*models.Scope, error) {
+	err := mysqlcore.New(r.db).UpdateScopeMember(ctx, mysqlcore.UpdateScopeMemberParams{
+		ScopeID: scope.ID,
+		UserID:  member.ID,
+		Name:    member.Name,
+		Owner:   member.Owner,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	found := false
+	scope.Members = append(scope.Members[:0:0], scope.Members...)
+	for i, member2 := range scope.Members {
+		if member2.ID == member.ID {
+			scope.Members[i] = member2
+			found = true
+		}
+	}
+	if !found {
+		scope.Members = append(scope.Members, member)
+		sort.Slice(scope.Members, func(i, j int) bool {
+			return scope.Members[i].Name < scope.Members[j].Name
+		})
+	}
+
+	return &scope, nil
+}
+
+func (r *scopeRepository) DeleteMember(ctx context.Context, scope models.Scope, userID string) (*models.Scope, error) {
+	err := mysqlcore.New(r.db).DeleteScopeMember(ctx, mysqlcore.DeleteScopeMemberParams{
+		ScopeID: scope.ID,
+		UserID:  userID,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	newMembers := make([]models.ScopeMember, 0, len(scope.Members)-1)
+	for _, member := range scope.Members {
+		if member.ID != userID {
+			newMembers = append(newMembers, member)
+		}
+	}
+	scope.Members = newMembers
+
+	return &scope, nil
+}

internal/database/mysql/stats.go

@@ -0,0 +1,144 @@
+package mysql
+
+import (
+	"context"
+	"database/sql"
+	"encoding/json"
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/database/mysql/mysqlcore"
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/models"
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/slerrors"
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/sqltypes"
+)
+
+type statsRepository struct {
+	db      *sql.DB
+	q       *mysqlcore.Queries
+	scopeID int
+}
+
+func (r *statsRepository) Find(ctx context.Context, id int) (*models.Stat, error) {
+	row, err := r.q.GetStat(ctx, mysqlcore.GetStatParams{ScopeID: r.scopeID, ID: id})
+	if err != nil {
+		if err == sql.ErrNoRows {
+			return nil, slerrors.NotFound("Stat")
+		}
+
+		return nil, err
+	}
+
+	return r.rowToStat(row), nil
+}
+
+func (r *statsRepository) List(ctx context.Context) ([]models.Stat, error) {
+	rows, err := r.q.ListStats(ctx, r.scopeID)
+	if err != nil && err != sql.ErrNoRows {
+		return nil, err
+	}
+
+	stats := make([]models.Stat, 0, len(rows))
+	for _, row := range rows {
+		stats = append(stats, *r.rowToStat(mysqlcore.GetStatRow(row)))
+	}
+
+	return stats, nil
+}
+
+func (r *statsRepository) Create(ctx context.Context, stat models.Stat) (*models.Stat, error) {
+	allowedAmounts := sqltypes.NullRawMessage{}
+	if stat.AllowedAmounts != nil && len(stat.AllowedAmounts) > 0 {
+		allowedAmounts.Valid = true
+		allowedAmounts.RawMessage, _ = json.Marshal(stat.AllowedAmounts)
+	}
+
+	res, err := r.q.InsertStat(ctx, mysqlcore.InsertStatParams{
+		ScopeID:        r.scopeID,
+		Name:           stat.Name,
+		Description:    stat.Description,
+		Weight:         stat.Weight,
+		AllowedAmounts: allowedAmounts,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	id, err := res.LastInsertId()
+	if err != nil {
+		return nil, err
+	}
+
+	return r.Find(ctx, int(id))
+}
+
+func (r *statsRepository) Update(ctx context.Context, stat models.Stat, update models.StatUpdate) (*models.Stat, error) {
+	stat.Update(update)
+	allowedAmounts := sqltypes.NullRawMessage{}
+	if stat.AllowedAmounts != nil && len(stat.AllowedAmounts) > 0 {
+		allowedAmounts.Valid = true
+		allowedAmounts.RawMessage, _ = json.Marshal(stat.AllowedAmounts)
+	}
+
+	err := r.q.UpdateStat(ctx, mysqlcore.UpdateStatParams{
+		Name:           stat.Name,
+		Description:    stat.Description,
+		Weight:         stat.Weight,
+		AllowedAmounts: allowedAmounts,
+		ID:             stat.ID,
+		ScopeID:        r.scopeID,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return &stat, nil
+}
+
+func (r *statsRepository) Delete(ctx context.Context, stat models.Stat) error {
+	tx, err := r.db.BeginTx(ctx, nil)
+	if err != nil {
+		return err
+	}
+	defer tx.Rollback()
+	q := r.q.WithTx(tx)
+
+	err = q.DeleteStat(ctx, mysqlcore.DeleteStatParams{ScopeID: r.scopeID, ID: stat.ID})
+	if err == sql.ErrNoRows {
+		return slerrors.NotFound("Stat")
+	}
+	if err != nil {
+		return err
+	}
+
+	err = q.CLearItemStatProgressByStat(ctx, stat.ID)
+	if err != nil {
+		return err
+	}
+	err = q.DeleteAllProjectRequirementStatsByStat(ctx, stat.ID)
+	if err != nil {
+		return err
+	}
+
+	// TODO: delete from Sprints
+
+	return tx.Commit()
+}
+
+func (r *statsRepository) rowToStat(row mysqlcore.GetStatRow) *models.Stat {
+	stat := models.Stat{
+		StatEntry: models.StatEntry{
+			ID:     row.ID,
+			Name:   row.Name,
+			Weight: row.Weight,
+		},
+		Description:    row.Description,
+		AllowedAmounts: nil,
+	}
+	if row.AllowedAmounts.Valid {
+		stat.AllowedAmounts = make(map[string]int)
+		_ = json.Unmarshal(row.AllowedAmounts.RawMessage, &stat)
+		if len(stat.AllowedAmounts) == 0 {
+			stat.AllowedAmounts = nil
+		}
+	}
+
+	return &stat
+}

internal/envvars/int.go

@@ -0,0 +1,20 @@
+package envvars
+
+import (
+	"os"
+	"strconv"
+)
+
+func Int(key string) int {
+	value := os.Getenv(key)
+	if value == "" {
+		return 0
+	}
+
+	intValue, err := strconv.Atoi(value)
+	if err != nil {
+		return 0
+	}
+
+	return intValue
+}

internal/envvars/string.go

@@ -0,0 +1,7 @@
+package envvars
+
+import "os"
+
+func String(key string) string {
+	return os.Getenv(key)
+}

internal/models/common.go

@@ -0,0 +1,46 @@
+package models
+
+import (
+	"encoding/json"
+	"fmt"
+	"time"
+)
+
+type Date [3]int
+
+func ParseDate(s string) (Date, error) {
+	date, err := time.ParseInLocation("2006-01-02", s, time.UTC)
+	if err != nil {
+		return [3]int{}, err
+	}
+
+	y, m, d := date.Date()
+	return Date{y, int(m), d}, nil
+}
+
+func (d *Date) UnmarshalJSON(b []byte) error {
+	var str string
+	err := json.Unmarshal(b, &str)
+	if err != nil {
+		return err
+	}
+
+	*d, err = ParseDate(str)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (d Date) String() string {
+	return fmt.Sprintf("%04d-%02d-%02d", d[0], d[1], d[2])
+}
+
+func (d Date) MarshalJSON() ([]byte, error) {
+	return []byte("\"" + d.String() + "\""), nil
+}
+
+func (d Date) ToTime() time.Time {
+	return time.Date(d[0], time.Month(d[1]), d[2], 0, 0, 0, 0, time.UTC)
+}

internal/models/date.go

@@ -0,0 +1 @@
+package models

internal/models/item.go

@@ -0,0 +1,85 @@
+package models
+
+import "time"
+
+type Item struct {
+	ID                   int    `json:"id"`
+	ScopeID              int    `json:"scopeId"`
+	OwnerID              string `json:"ownerId"`
+	ProjectID            *int   `json:"projectId,omitempty"`
+	ProjectRequirementID *int   `json:"projectRequirementId,omitempty"`
+
+	Name          string     `json:"name"`
+	Description   string     `json:"description"`
+	CreatedTime   time.Time  `json:"createdTime"`
+	AcquiredTime  *time.Time `json:"acquiredTime"`
+	ScheduledDate *Date      `json:"scheduledDate"`
+
+	Stats []StatProgressEntry `json:"stats,omitempty"`
+}
+
+func (item *Item) ApplyUpdate(update ItemUpdate) {
+	if update.ProjectRequirementID != nil {
+		item.ProjectRequirementID = update.ProjectRequirementID
+	}
+	if update.OwnerID != nil {
+		item.OwnerID = *update.OwnerID
+	}
+	if update.Name != nil {
+		item.Name = *update.Name
+	}
+	if update.Description != nil {
+		item.Description = *update.Description
+	}
+	if update.AcquiredTime != nil {
+		item.AcquiredTime = update.AcquiredTime
+	}
+	if update.ScheduledDate != nil {
+		item.ScheduledDate = update.ScheduledDate
+	}
+	if update.ClearScheduledDate {
+		item.ScheduledDate = nil
+	}
+	if update.ClearProjectRequirementID {
+		item.ProjectRequirementID = nil
+	}
+	if update.ClearAcquiredTime {
+		item.AcquiredTime = nil
+	}
+
+	deleteList := make([]int, 0, len(update.Stats))
+	for i, stat := range update.Stats {
+		if stat.Acquired == 0 && stat.Required == 0 {
+			deleteList = append(deleteList, i-len(deleteList))
+		}
+
+		found := false
+		for j := range item.Stats {
+			if item.Stats[j].ID == stat.ID {
+				item.Stats[j].Required = stat.Required
+				item.Stats[j].Acquired = stat.Acquired
+
+				found = true
+				break
+			}
+		}
+		if !found {
+			item.Stats = append(item.Stats, stat)
+		}
+	}
+}
+
+type ItemUpdate struct {
+	ProjectRequirementID *int       `json:"projectRequirementId"`
+	OwnerID              *string    `json:"ownerId"`
+	Name                 *string    `json:"name"`
+	Description          *string    `json:"description"`
+	AcquiredTime         *time.Time `json:"acquiredTime"`
+	ScheduledDate        *Date      `json:"scheduledDate"`
+
+	Stats []StatProgressEntry `json:"stats"`
+
+	ClearProjectRequirementID bool `json:"clearProjectRequirementId"`
+	ClearAcquiredTime         bool `json:"clearAcquiredTime"`
+	ClearScheduledDate        bool `json:"clearScheduledDate"`
+}

internal/models/project.go

@@ -0,0 +1,98 @@
+package models
+
+import "time"
+
+type ProjectEntry struct {
+	ID          int       `json:"id"`
+	OwnerID     string    `json:"ownerId,omitempty"`
+	CreatedTime time.Time `json:"createdTime"`
+	Name        string    `json:"name"`
+	Status      Status    `json:"status"`
+}
+
+type ProjectRequirement struct {
+	ID          int                 `json:"id"`
+	Name        string              `json:"name"`
+	Description string              `json:"description"`
+	Status      Status              `json:"status"`
+	Stats       []StatProgressEntry `json:"stats,omitempty"`
+	Items       []Item              `json:"items,omitempty"`
+}
+
+func (requirement *ProjectRequirement) Update(update ProjectRequirementUpdate) {
+	if update.Name != nil {
+		requirement.Name = *update.Name
+	}
+	if update.Description != nil {
+		requirement.Description = *update.Description
+	}
+	if update.Status != nil {
+		requirement.Status = *update.Status
+	}
+
+	deleteList := make([]int, 0, len(update.Stats))
+	for i, stat := range update.Stats {
+		if stat.Acquired == 0 && stat.Required == 0 {
+			deleteList = append(deleteList, i-len(deleteList))
+		}
+
+		found := false
+		for j := range requirement.Stats {
+			if requirement.Stats[j].ID == stat.ID {
+				requirement.Stats[j].Required = stat.Required
+				requirement.Stats[j].Acquired = stat.Acquired
+
+				found = true
+				break
+			}
+		}
+		if !found {
+			requirement.Stats = append(requirement.Stats, stat)
+		}
+	}
+}
+
+type ProjectRequirementUpdate struct {
+	Name        *string             `json:"name"`
+	Description *string             `json:"description"`
+	Status      *Status             `json:"status"`
+	Stats       []StatProgressEntry `json:"stats"`
+}
+
+type Project struct {
+	ProjectEntry
+	Description  string               `json:"description"`
+	Requirements []ProjectRequirement `json:"requirements"`
+}
+
+func (project *Project) Update(update ProjectUpdate) {
+	if update.OwnerID != nil {
+		project.OwnerID = *update.OwnerID
+	}
+	if update.Name != nil {
+		project.Name = *update.Name
+	}
+	if update.Description != nil {
+		project.Description = *update.Description
+	}
+	if update.Status != nil {
+		project.Status = *update.Status
+	}
+}
+
+func (project *Project) Requirement(id int) *ProjectRequirement {
+	for i, requirement := range project.Requirements {
+		if requirement.ID == id {
+			return &project.Requirements[i]
+		}
+	}
+
+	return nil
+}
+
+type ProjectUpdate struct {
+	Name        *string `json:"name,omitempty"`
+	OwnerID     *string `json:"ownerId,omitempty"`
+	Status      *Status `json:"status,omitempty"`
+	Description *string `json:"description,omitempty"`
+}

internal/models/scope.go

@@ -0,0 +1,53 @@
+package models
+
+type ScopeEntry struct {
+	ID           int    `json:"id"`
+	Name         string `json:"name"`
+	Abbreviation string `json:"abbreviation"`
+}
+
+type ScopeMember struct {
+	ID    string `json:"id"`
+	Name  string `json:"name"`
+	Owner bool   `json:"owner"`
+}
+
+type Scope struct {
+	ScopeEntry
+
+	DisplayName  string            `json:"displayName"`
+	Members      []ScopeMember     `json:"members"`
+	Projects     []ProjectEntry    `json:"projects"`
+	Stats        []Stat            `json:"stats"`
+	StatusLabels map[Status]string `json:"statusLabels"` // Not stored as part of scope, but may be in the future.
+}
+
+func (s *Scope) Member(id string) *ScopeMember {
+	for _, user := range s.Members {
+		if user.ID == id {
+			return &user
+		}
+	}
+
+	return nil
+}
+
+func (s *Scope) HasMember(id string) bool {
+	for _, user := range s.Members {
+		if user.ID == id {
+			return true
+		}
+	}
+
+	return false
+}
+
+func (s *Scope) Stat(id int) *Stat {
+	for _, stat := range s.Stats {
+		if stat.ID == id {
+			return &stat
+		}
+	}
+
+	return nil
+}

internal/models/stat.go

@@ -0,0 +1,70 @@
+package models
+
+type StatEntry struct {
+	ID     int     `json:"id"`
+	Name   string  `json:"name"`
+	Weight float64 `json:"weight"`
+}
+
+type StatProgressEntry struct {
+	StatEntry
+
+	Acquired int `json:"acquired"`
+	Required int `json:"required"`
+}
+
+type Stat struct {
+	StatEntry
+
+	Description    string         `json:"description"`
+	AllowedAmounts map[string]int `json:"allowedAmounts"`
+}
+
+func (stat *Stat) Update(update StatUpdate) {
+	if update.Name != nil {
+		stat.Name = *update.Name
+	}
+	if update.Description != nil {
+		stat.Description = *update.Description
+	}
+	if update.Weight != nil {
+		stat.Weight = *update.Weight
+	}
+	for key, value := range update.AllowedAmounts {
+		if stat.AllowedAmounts == nil {
+			stat.AllowedAmounts = make(map[string]int, len(update.AllowedAmounts))
+		}
+		if value <= 0 {
+			delete(stat.AllowedAmounts, key)
+		} else {
+			stat.AllowedAmounts[key] = value
+		}
+	}
+	if len(stat.AllowedAmounts) == 0 {
+		stat.AllowedAmounts = nil
+	}
+}
+
+type StatUpdate struct {
+	Name           *string        `json:"name"`
+	Description    *string        `json:"description"`
+	Weight         *float64       `json:"weight"`
+	AllowedAmounts map[string]int `json:"allowedAmounts"`
+}
+
+func (stat *Stat) AllowsAmount(amount int) bool {
+	if stat == nil {
+		return false
+	}
+	if stat.AllowedAmounts == nil || len(stat.AllowedAmounts) == 0 {
+		return true
+	}
+
+	for _, v := range stat.AllowedAmounts {
+		if v == amount {
+			return true
+		}
+	}
+
+	return false
+}

internal/models/status.go

@@ -0,0 +1,29 @@
+package models
+
+type Status int
+
+func (s Status) Valid() bool {
+	return s >= 0 && s < maxStatus
+}
+
+const (
+	Blocked Status = iota
+	Available
+	Background
+	Active
+	Completed
+	Failed
+	Dropped
+
+	maxStatus
+)
+
+var StatusLabels = map[Status]string{
+	Blocked:    "Blocked",
+	Available:  "Available",
+	Background: "Background",
+	Active:     "Active",
+	Completed:  "Completed",
+	Failed:     "Failed",
+	Dropped:    "Dropped",
+}

internal/slerrors/badrequest.go

@@ -0,0 +1,18 @@
+package slerrors
+
+type badRequestError struct {
+	Text string
+}
+
+func (err *badRequestError) Error() string {
+	return "validation failed: " + err.Text
+}
+
+func BadRequest(text string) error {
+	return &badRequestError{Text: text}
+}
+
+func IsBadRequest(err error) bool {
+	_, ok := err.(*badRequestError)
+	return ok
+}

internal/slerrors/forbidden.go

@@ -0,0 +1,22 @@
+package slerrors
+
+type forbiddenError struct {
+	Message string
+}
+
+func (e *forbiddenError) Error() string {
+	return e.Message
+}
+
+func Forbidden(message string) error {
+	return &forbiddenError{Message: message}
+}
+
+func IsForbidden(err error) bool {
+	if err == nil {
+		return false
+	}
+
+	_, ok := err.(*forbiddenError)
+	return ok
+}

internal/slerrors/gin.go

@@ -0,0 +1,35 @@
+package slerrors
+
+import (
+	"github.com/gin-gonic/gin"
+	"net/http"
+)
+
+type ErrorResponse struct {
+	Code    int    `json:"errorCode"`
+	Message string `json:"errorMessage"`
+}
+
+func Respond(c *gin.Context, err error) {
+	if IsNotFound(err) {
+		c.JSON(http.StatusNotFound, ErrorResponse{
+			Code:    http.StatusNotFound,
+			Message: err.Error(),
+		})
+	} else if IsForbidden(err) {
+		c.JSON(http.StatusForbidden, ErrorResponse{
+			Code:    http.StatusForbidden,
+			Message: err.Error(),
+		})
+	} else if IsBadRequest(err) {
+		c.JSON(http.StatusBadRequest, ErrorResponse{
+			Code:    http.StatusBadRequest,
+			Message: err.Error(),
+		})
+	} else {
+		c.JSON(http.StatusInternalServerError, ErrorResponse{
+			Code:    http.StatusInternalServerError,
+			Message: err.Error(),
+		})
+	}
+}

internal/slerrors/notfound.go

@@ -0,0 +1,18 @@
+package slerrors
+
+type notFoundError struct {
+	Subject string
+}
+
+func (err *notFoundError) Error() string {
+	return err.Subject + " not found or inaccessible"
+}
+
+func NotFound(subject string) error {
+	return &notFoundError{Subject: subject}
+}
+
+func IsNotFound(err error) bool {
+	_, ok := err.(*notFoundError)
+	return ok
+}

internal/sqltypes/nulldate.go

@@ -0,0 +1,46 @@
+package sqltypes
+
+import (
+	"database/sql/driver"
+	"errors"
+	"git.aiterp.net/stufflog3/stufflog3-api/internal/models"
+	"time"
+)
+
+type NullDate struct {
+	Date  models.Date
+	Valid bool
+}
+
+func (n *NullDate) Scan(value interface{}) error {
+	if value == nil {
+		n.Valid = false
+		return nil
+	}
+
+	switch value := value.(type) {
+	case string:
+		date, err := models.ParseDate(value)
+		if err != nil {
+			return err
+		}
+
+		n.Date = date
+		n.Valid = true
+	case time.Time:
+		n.Date = models.Date{value.Year(), int(value.Month()), value.Day()}
+		n.Valid = true
+	default:
+		return errors.New("invalid type")
+	}
+
+	return nil
+}
+
+func (n NullDate) Value() (driver.Value, error) {
+	if !n.Valid {
+		return nil, nil
+	}
+
+	return n.Date.String(), nil
+}

internal/sqltypes/nullrawmessage.go

@@ -0,0 +1,36 @@
+package sqltypes
+
+import (
+	"database/sql/driver"
+	"encoding/json"
+	"errors"
+)
+
+type NullRawMessage struct {
+	RawMessage json.RawMessage
+	Valid      bool
+}
+
+func (n *NullRawMessage) Scan(value interface{}) error {
+	if value == nil {
+		n.RawMessage, n.Valid = json.RawMessage{}, false
+		return nil
+	}
+	buf, ok := value.([]byte)
+
+	if !ok {
+		return errors.New("cannot parse to bytes")
+	}
+
+	n.RawMessage, n.Valid = buf, true
+
+	return nil
+}
+
+func (n NullRawMessage) Value() (driver.Value, error) {
+	if !n.Valid {
+		return nil, nil
+	}
+
+	return []byte(n.RawMessage), nil
+}

scripts/goose-mysql/20220313115117_scope.sql

@@ -4,7 +4,7 @@ CREATE TABLE scope (
   `id` INT NOT NULL PRIMARY KEY AUTO_INCREMENT,
   `name` VARCHAR(255) NOT NULL,
   `abbreviation` CHAR(8) NOT NULL
-)
+);
 -- +goose StatementEnd
 
 -- +goose Down

scripts/goose-mysql/20220326174046_project.sql

@@ -9,7 +9,7 @@ CREATE TABLE project (
   `description` TEXT NOT NULL,
 
   UNIQUE (`scope_id`, `name`)
-)
+);
 -- +goose StatementEnd
 
 -- +goose Down

scripts/goose-mysql/20220404184237_project_requirement_stat.sql

@@ -6,7 +6,7 @@ CREATE TABLE project_requirement_stat (
   `required` INT NOT NULL,
 
   PRIMARY KEY (`project_requirement_id`, `stat_id`)
-)
+);
 -- +goose StatementEnd
 
 -- +goose Down

scripts/goose-mysql/20220411190154_project_created_time.sql

@@ -0,0 +1,9 @@
+-- +goose Up
+-- +goose StatementBegin
+ALTER TABLE project ADD COLUMN created_time TIMESTAMP NOT NULL DEFAULT NOW();
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+ALTER TABLE project DROP COLUMN IF EXISTS created_time;
+-- +goose StatementEnd