add routines command

- it loads procedures from database and saves them to file for later use

Author: ZelvaMan

.editorconfig

@@ -9,23 +9,31 @@ import (
 	"log"
 )
 
+const (
+	keyDebug            = "debug"
+	keyConnectionString = "connectionString"
+	keyConfig           = "config"
+)
+
 var generateCmd = &cobra.Command{
 	Use:   "generate",
 	Short: "Generate code",
 	Long:  "Generate code for calling database stored procedures",
 	Run: func(cmd *cobra.Command, args []string) {
-		configLocation := viper.GetString("config")
+		common.BindBoolFlag(cmd, keyDebug)
+		common.BindStringFlag(cmd, keyConnectionString)
+		common.BindStringFlag(cmd, keyConfig)
 
-		_, err := dbGen.ReadConfig(configLocation)
+		_, err := dbGen.ReadConfig(viper.GetString(keyConfig))
 		if err != nil {
-			dbGen.Exit("configuration error: %s", err)
+			common.Exit("configuration error: %s", err)
 		}
 
 		viper.AutomaticEnv() // read in environment variables that match
 
 		err = doGenerate()
 		if err != nil {
-			dbGen.Exit(err.Error())
+			common.Exit(err.Error())
 		}
 	},
 }
@@ -34,10 +42,9 @@ func init() {
 	rootCmd.AddCommand(generateCmd)
 
 	// set cli flags
-	common.ConfigurationBool(generateCmd, "debug", "d", false, "Print debug logs and create debug files")
-	common.ConfigurationString(generateCmd, "connectionString", "s", "", "Connection string used to connect to database")
-	common.ConfigurationString(generateCmd, "config", "c", "", "Path to configuration file")
-
+	common.DefineBoolFlag(generateCmd, keyDebug, "d", false, "Print debug logs and create debug files")
+	common.DefineStringFlag(generateCmd, keyConnectionString, "s", "", "Connection string used to connect to database")
+	common.DefineStringFlag(generateCmd, keyConfig, "c", "", "Path to configuration file")
 }
 
 func doGenerate() error {
@@ -65,7 +72,7 @@ func doGenerate() error {
 
 	if config.Debug {
 		common.LogDebug("Saving to debug file...")
-		err = dbGen.SaveToTempFile(routines, "dbRoutines")
+		err = common.SaveToTempFile(routines, "dbRoutines")
 		if err != nil {
 			return fmt.Errorf("error saving debug file: %s", err)
 		}
@@ -80,7 +87,7 @@ func doGenerate() error {
 
 	if config.Debug {
 		common.LogDebug("Saving to debug file...")
-		err = dbGen.SaveToTempFile(processedFunctions, "mapped")
+		err = common.SaveToTempFile(processedFunctions, "mapped")
 		if err != nil {
 			return fmt.Errorf("error saving debug file: %s", err)
 		}

.github/workflows/go.yml

@@ -0,0 +1,82 @@
+package cmd
+
+import (
+	"fmt"
+	"github.com/keenmate/db-gen/common"
+	dbGen "github.com/keenmate/db-gen/src"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+	"log"
+)
+
+var getRoutinesCmd = &cobra.Command{
+	Use:   "routines [out]",
+	Short: "Get routines",
+	Long:  "Get routines from database to generate later",
+	Run: func(cmd *cobra.Command, args []string) {
+		common.BindBoolFlag(cmd, keyDebug)
+		common.BindStringFlag(cmd, keyConnectionString)
+		common.BindStringFlag(cmd, keyConfig)
+
+		configLocation := viper.GetString("config")
+
+		_, err := dbGen.ReadConfig(configLocation)
+		if err != nil {
+			common.Exit("configuration error: %s", err)
+		}
+
+		log.Printf("arguments: %s", args)
+
+		viper.AutomaticEnv() // read in environment variables that match
+
+		err = doGetRoutines()
+
+		if err != nil {
+			common.Exit(err.Error())
+		}
+	},
+}
+
+func init() {
+	rootCmd.AddCommand(getRoutinesCmd)
+
+	// set cli flags
+	common.DefineBoolFlag(getRoutinesCmd, keyDebug, "d", false, "Print debug logs and create debug files")
+	common.DefineStringFlag(getRoutinesCmd, keyConnectionString, "s", "", "Connection string used to connect to database")
+	common.DefineStringFlag(getRoutinesCmd, keyConfig, "c", "", "Path to configuration file")
+}
+
+func doGetRoutines() error {
+	log.Printf("Getting configurations...")
+
+	config, err := dbGen.GetAndValidateConfig()
+	if err != nil {
+		return fmt.Errorf("error getting config %s", err)
+	}
+
+	common.LogDebug("Debug logging is enabled")
+
+	log.Printf("Connecting to database...")
+	conn, err := dbGen.Connect(config.ConnectionString)
+	if err != nil {
+		return fmt.Errorf("error connecting to database: %s", err)
+	}
+
+	log.Printf("Getting routines...")
+	routines, err := dbGen.GetRoutines(conn, config)
+	if err != nil {
+		return fmt.Errorf("error getting routines: %s", err)
+	}
+
+	log.Printf("Saving %d routines...", len(routines))
+
+	// TODO show what routines changed
+
+	err = common.SaveAsJson(config.RoutinesFile, routines)
+	if err != nil {
+		return fmt.Errorf("error saving routines: %s", err)
+	}
+	log.Printf("File saved at %s", config.RoutinesFile)
+
+	return nil
+}

.github/workflows/release.yml

@@ -14,7 +14,7 @@ var rootCmd = &cobra.Command{
 	Short: "Code generator for stored procedures and functions",
 	Long: `DB-GEN by KEEN|MATE
 ---------
-TODO better description
+For more information, see github.com/keenmate/db-gen
 `,
 }
 
@@ -42,7 +42,6 @@ func init() {
 
 }
 
-// initConfig reads in config file and ENV variables if set.
 func initConfig() {
 
 }

.gitignore

@@ -5,11 +5,20 @@ import (
 	"github.com/spf13/viper"
 )
 
-func ConfigurationString(command *cobra.Command, key string, shorthand string, defaultValue string, usage string) {
+func DefineStringFlag(command *cobra.Command, key string, shorthand string, defaultValue string, usage string) {
 	command.Flags().StringP(key, shorthand, defaultValue, usage)
-	_ = viper.BindPFlag(key, command.Flags().Lookup(key))
 }
-func ConfigurationBool(command *cobra.Command, key string, shorthand string, defaultValue bool, usage string) {
+
+func DefineBoolFlag(command *cobra.Command, key string, shorthand string, defaultValue bool, usage string) {
 	command.Flags().BoolP(key, shorthand, defaultValue, usage)
+}
+
+// Due to bug/design flaw in viper, we need to bind flags only after we run function
+
+func BindStringFlag(command *cobra.Command, key string) {
+	_ = viper.BindPFlag(key, command.Flags().Lookup(key))
+}
+
+func BindBoolFlag(command *cobra.Command, key string) {
 	_ = viper.BindPFlag(key, command.Flags().Lookup(key))
 }

.idea/.gitignore

@@ -1,8 +1,7 @@
-package dbGen
+package common
 
 import (
 	"encoding/json"
-	"github.com/keenmate/db-gen/common"
 	"os"
 	"path/filepath"
 	"time"
@@ -23,7 +22,7 @@ func SaveToTempFile(content interface{}, fileNamePrefix string) (err error) {
 	}
 
 	filename := filepath.Join(tempFolder, time.Now().Format("2006-01-02-15-04-05")+"-"+fileNamePrefix+".json")
-	common.LogDebug("Temp file saved: %s", filename)
+	LogDebug("Temp file saved: %s", filename)
 
 	err = os.WriteFile(filename, saveJson, 0777)
 	if err != nil {

.idea/dataSources.xml

@@ -1,12 +1,24 @@
 package common
 
 import (
+	"encoding/json"
+	"errors"
+	"fmt"
 	"os"
 	"path/filepath"
 )
 
 func PathExists(path string) bool {
-	if _, err := os.Stat(path); os.IsNotExist(err) {
+	// this doesnt work work if some part of path does not exist
+	if _, err := os.Stat(path); errors.Is(err, os.ErrNotExist) {
+		return false
+	}
+	return true
+}
+
+func FileIsReadable(path string) bool {
+	_, err := os.Stat(path)
+	if err != nil {
 		return false
 	}
 	return true
@@ -30,3 +42,20 @@ func RemoveContents(dir string) error {
 	}
 	return nil
 }
+
+func SaveAsJson(path string, data interface{}) error {
+	LogDebug("Saving data as json to %s", path)
+
+	// intent is not necessary, but will make our life easier
+	saveJson, err := json.MarshalIndent(data, "", "  ")
+	if err != nil {
+		return fmt.Errorf("converting data to json: %s", err)
+	}
+
+	err = os.WriteFile(path, saveJson, 0777)
+	if err != nil {
+		return fmt.Errorf("writing file: %s", err)
+	}
+
+	return nil
+}

.idea/db-gen.iml

@@ -0,0 +1,19 @@
+package common
+
+import (
+	"os"
+)
+
+func Exit(template string, args ...any) {
+	LogError(colorRed+template+colorReset, args...)
+	os.Exit(1)
+}
+
+func Contains[T comparable](s []T, e T) bool {
+	for _, a := range s {
+		if a == e {
+			return true
+		}
+	}
+	return false
+}

.idea/inspectionProfiles/Project_Default.xml

@@ -30,6 +30,7 @@ type Config struct {
 	GeneratedFileCase                string         `mapstructure:"GeneratedFileCase"`
 	Debug                            bool           `mapstructure:"Debug"`
 	ClearOutputFolder                bool           `mapstructure:"ClearOutputFolder"`
+	RoutinesFile                     string         `mapstructure:"RoutinesFile"`
 	Generate                         []SchemaConfig `mapstructure:"Generate"`
 	Mappings                         []Mapping      `mapstructure:"Mappings"`
 }
@@ -72,6 +73,7 @@ func GetAndValidateConfig() (*Config, error) {
 		ClearOutputFolder:                false,
 		Generate:                         nil,
 		Mappings:                         nil,
+		RoutinesFile:                     "./db-gen-routines.json",
 	}
 
 	err := viper.Unmarshal(config)
@@ -91,9 +93,10 @@ func GetAndValidateConfig() (*Config, error) {
 	config.DbContextTemplate = joinIfRelative(config.PathBase, config.DbContextTemplate)
 	config.ModelTemplate = joinIfRelative(config.PathBase, config.ModelTemplate)
 	config.OutputFolder = joinIfRelative(config.PathBase, config.OutputFolder)
+	config.RoutinesFile = joinIfRelative(config.PathBase, config.RoutinesFile)
 	config.GeneratedFileCase = strings.ToLower(config.GeneratedFileCase)
 
-	if !contains(ValidCaseNormalized, config.GeneratedFileCase) {
+	if !common.Contains(ValidCaseNormalized, config.GeneratedFileCase) {
 		return nil, fmt.Errorf(" '%s' is not valid case (maybe GeneratedFileCase is missing)", config.GeneratedFileCase)
 	}
 
@@ -142,6 +145,8 @@ func ReadConfig(configLocation string) (string, error) {
 		return configLocation, nil
 	}
 
+	common.LogDebug("No configuration file set, trying default locations")
+
 	for _, defaultConfigPath := range defaultConfigPaths {
 		fileExists, err := TryReadConfigFile(defaultConfigPath)
 		if fileExists {
@@ -188,7 +193,8 @@ func TryReadLocalConfig(configLocation string) (bool, error) {
 func TryReadConfigFile(configPath string) (bool, error) {
 	common.LogDebug("Trying to read config file: %s", configPath)
 
-	if !common.PathExists(configPath) {
+	// TODO this could hide some usefull errors, maybe log the reason in debug mode
+	if !common.FileIsReadable(configPath) {
 		return false, nil
 	}