(Feat): Initial Commit

scripts/cmd/handlers.go

@@ -0,0 +1,29 @@
+//go:build scripts
+
+package cmd
+
+import (
+	"os"
+
+	"github.com/rs/zerolog/log"
+	"github.com/spf13/cobra"
+)
+
+// handlersCmd represents the handlers command
+// see handlers_*.go for sub_commands
+var handlersCmd = &cobra.Command{
+	Use:   "handlers <subcommand>",
+	Short: "Handlers related subcommands",
+	Run: func(cmd *cobra.Command, _ []string /* args */) {
+		if err := cmd.Help(); err != nil {
+			log.Error().Err(err).Msg("Failed to print help")
+			os.Exit(1)
+		}
+		os.Exit(0)
+	},
+}
+
+//nolint:gochecknoinits
+func init() {
+	rootCmd.AddCommand(handlersCmd)
+}

scripts/cmd/handlers_check.go

@@ -0,0 +1,37 @@
+//go:build scripts
+
+package cmd
+
+import (
+	"log"
+
+	"allaboutapps.dev/aw/go-starter/scripts/internal/handlers"
+	"github.com/spf13/cobra"
+)
+
+const (
+	printAllFlag = "print-all"
+)
+
+var handlersCheckCmd = &cobra.Command{
+	Use:   "check",
+	Short: "Checks handlers vs. swagger spec.",
+	Long:  `Checks currently implemented handlers against swagger spec.`,
+	Run: func(cmd *cobra.Command, _ []string /* args */) {
+
+		printAll, err := cmd.Flags().GetBool(printAllFlag)
+		if err != nil {
+			log.Fatal(err)
+		}
+		err = handlers.CheckHandlers(printAll)
+		if err != nil {
+			log.Fatal(err)
+		}
+	},
+}
+
+//nolint:gochecknoinits
+func init() {
+	handlersCmd.AddCommand(handlersCheckCmd)
+	handlersCheckCmd.Flags().Bool(printAllFlag, false, "Print only print the current implemented handlers, do not generate the file.")
+}

scripts/cmd/handlers_gen.go

@@ -0,0 +1,38 @@
+//go:build scripts
+
+package cmd
+
+import (
+	"log"
+
+	"allaboutapps.dev/aw/go-starter/scripts/internal/handlers"
+	"github.com/spf13/cobra"
+)
+
+const (
+	printOnlyFlag = "print-only"
+)
+
+var handlersGenCmd = &cobra.Command{
+	Use:   "gen",
+	Short: "Generate internal/api/handlers/handlers.go.",
+	Long:  `Generates internal/api/handlers/handlers.go file based on the current implemented handlers.`,
+	Run: func(cmd *cobra.Command, _ []string /* args */) {
+
+		printOnly, err := cmd.Flags().GetBool(printOnlyFlag)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		err = handlers.GenHandlers(printOnly)
+		if err != nil {
+			log.Fatal(err)
+		}
+	},
+}
+
+//nolint:gochecknoinits
+func init() {
+	handlersCmd.AddCommand(handlersGenCmd)
+	handlersGenCmd.Flags().Bool(printOnlyFlag, false, "Print all checked handlers regardless of errors.")
+}

scripts/cmd/modulename.go

@@ -0,0 +1,34 @@
+//go:build scripts
+
+package cmd
+
+import (
+	"allaboutapps.dev/aw/go-starter/scripts/internal/util"
+	"github.com/rs/zerolog/log"
+	"github.com/spf13/cobra"
+)
+
+// moduleCmd represents the server command
+var moduleCmd = &cobra.Command{
+	Use:   "modulename",
+	Short: "Prints the modulename",
+	Long:  `Prints the currently applied go modulename of this project.`,
+	Run: func(_ *cobra.Command /* cmd */, _ []string /* args */) {
+		runModulename()
+	},
+}
+
+//nolint:gochecknoinits
+func init() {
+	rootCmd.AddCommand(moduleCmd)
+}
+
+func runModulename() {
+	baseModuleName, err := util.GetModuleName(modulePath)
+
+	if err != nil {
+		log.Fatal().Err(err).Msg("Failed to get module name")
+	}
+
+	log.Info().Msg(baseModuleName)
+}

scripts/cmd/root.go

@@ -0,0 +1,34 @@
+//go:build scripts
+
+package cmd
+
+import (
+	"os"
+	"path/filepath"
+
+	"allaboutapps.dev/aw/go-starter/scripts/internal/util"
+	"github.com/rs/zerolog/log"
+	"github.com/spf13/cobra"
+)
+
+var (
+	projectRoot = util.GetProjectRootDir()
+	modulePath  = filepath.Join(util.GetProjectRootDir(), "go.mod")
+)
+
+// rootCmd represents the base command when called without any subcommands
+var rootCmd = &cobra.Command{
+	Use:   "gsdev",
+	Short: "gsdev",
+	Long: `go-starter development scripts
+Utility commands while developing go-starter based projects.`,
+}
+
+// Execute adds all child commands to the root command and sets flags appropriately.
+// This is called by main.main(). It only needs to happen once to the rootCmd.
+func Execute() {
+	if err := rootCmd.Execute(); err != nil {
+		log.Error().Err(err).Msg("Failed to execute root command")
+		os.Exit(1)
+	}
+}

scripts/cmd/scaffold.go

@@ -0,0 +1,86 @@
+//go:build scripts
+
+package cmd
+
+import (
+	"log"
+	"os/exec"
+	"path/filepath"
+
+	"allaboutapps.dev/aw/go-starter/scripts/internal/scaffold"
+	"github.com/spf13/cobra"
+)
+
+const (
+	methodsFlag = "methods"
+	forceFlag   = "force"
+)
+
+var (
+	modelPath   = filepath.Join(projectRoot, "internal/models")
+	swaggerPath = filepath.Join(projectRoot, "api")
+	handlerPath = filepath.Join(projectRoot, "internal/api/handlers")
+
+	makeSwaggerCmd    = exec.Command("make", "swagger")
+	makeGoGenerateCmd = exec.Command("make", "go-generate")
+
+	defaultMethods = []string{"get-all", "get", "post", "put", "delete"}
+)
+
+// rootCmd represents the base command when called without any subcommands
+var scaffoldCmd = &cobra.Command{
+	Use:   "scaffold [resource name]",
+	Short: "Scaffolding tool for CRUD endpoints.",
+	Long:  "Scaffolding tool to generate CRUD endpoint stubs from sqlboiler model definitions.",
+	Run:   generate,
+}
+
+//nolint:gochecknoinits
+func init() {
+	rootCmd.AddCommand(scaffoldCmd)
+	scaffoldCmd.Flags().StringSliceP(methodsFlag, "m", defaultMethods, "Specify HTTP methods to generate handlers for. Example: scaffold --methods get-all,get,delete")
+	scaffoldCmd.Flags().BoolP(forceFlag, "f", false, "Forces the tool to overwrite existing files.")
+}
+
+func generate(cmd *cobra.Command, args []string) {
+	if len(args) < 1 {
+		log.Fatal("Please provide a valid resource name")
+	}
+
+	resourceName := args[0]
+	if resourceName == "" {
+		log.Fatal("Please provide a valid resource name")
+	}
+
+	methods, err := cmd.Flags().GetStringSlice(methodsFlag)
+	if err != nil {
+		log.Fatalf("Failed to read %s: %v", methodsFlag, err)
+	}
+
+	force, err := cmd.Flags().GetBool(forceFlag)
+	if err != nil {
+		log.Fatalf("Failed to read %s: %v", forceFlag, err)
+	}
+
+	resourcePath := filepath.Join(modelPath, resourceName+".go")
+	resource, err := scaffold.ParseModel(resourcePath)
+	if err != nil {
+		log.Fatalf("Failed to parse resource from model file: %v", err)
+	}
+
+	if err = scaffold.GenerateSwagger(resource, swaggerPath, force); err != nil {
+		log.Fatalf("Failed to generate Swagger spec: %v", err)
+	}
+
+	if err = scaffold.GenerateHandlers(resource, handlerPath, modulePath, methods, force); err != nil {
+		log.Fatalf("Failed to generate handlers: %v", err)
+	}
+
+	if err = makeSwaggerCmd.Run(); err != nil {
+		log.Fatalf("Failed to run 'make swagger': %v", err)
+	}
+
+	if err = makeGoGenerateCmd.Run(); err != nil {
+		log.Fatalf("Failed to run 'make go-generate': %v", err)
+	}
+}