generate

Documentation

Index

• Variables
• func GetTime() string

Variables

var DashboardCmd = &cobra.Command{
	Use:   "dashboard",
	Short: "Generate dashboard under packages",
	RunE: func(cmd *cobra.Command, args []string) error {
		run := genny.WetRunner(context.Background())
		gg := &genny.Group{}

		g, err := dashboard.New(&dashboard.Options{})
		if err != nil {
			return err
		}

		gg.Add(g)
		run.WithGroup(gg)
		return run.Run()
	},
}

var GraphqlCmd = &cobra.Command{
	Use:   "graphql",
	Short: "generate a graphql server based on schema",
	RunE: func(cmd *cobra.Command, args []string) error {
		run := genny.WetRunner(context.Background())
		run.Logger = logger.New(logger.DebugLevel)

		graphqlGen, err := graphql.New()
		if err != nil {
			return err
		}
		err = run.With(graphqlGen)
		if err != nil {
			return err
		}
		return run.Run()
	},
}

var MigrationCmd = &cobra.Command{
	Use:   "migration",
	Short: "Generate new migration file",
	RunE: func(cmd *cobra.Command, args []string) error {
		name := args[0]
		time := GetTime()

		run := genny.WetRunner(context.Background())

		g, err := migration.New(&migration.Options{
			Name:    flect.New(name),
			Time:    time,
			Dialect: "postgres",
		})
		if err != nil {
			return err
		}
		run.With(g)
		return run.Run()
	},
}

var ModelCmd = &cobra.Command{
	Use:     "model",
	Short:   "Generate model",
	Example: "dashi generate model post title:string content:text",
	RunE: func(cmd *cobra.Command, args []string) error {
		name := ""
		if len(args) > 0 {
			name = args[0]
		}

		var (
			atts attrs.Attrs
			err  error
		)
		if len(args) > 1 {
			atts, err = attrs.ParseArgs(args[1:]...)
			if err != nil {
				return err
			}
		}

		run := genny.WetRunner(context.Background())

		mops := &model.Options{
			Name:                   flect.New(flect.Pascalize(name)).Singularize(),
			Attrs:                  atts,
			Path:                   "models",
			Package:                "models",
			TestPackage:            "models",
			ForceDefaultID:         true,
			ForceDefaultTimestamps: true,
		}
		if err := mops.Validate(); err != nil {
			return err
		}
		modelGen, err := model.New(mops)
		if err != nil {
			return err
		}

		migrationGen, err := migration.New(&migration.Options{
			Dialect: "postgres",
			Name:    mops.Name,
			Time:    GetTime(),
			Attrs:   mops.Attrs,
		})
		if err != nil {
			return err
		}

		run.With(modelGen)
		run.With(migrationGen)

		return run.Run()
	},
}

var PackagesCmd = &cobra.Command{
	Use:     "packages",
	Short:   "Generate packages",
	Example: "dashi g packages",
	RunE: func(cmd *cobra.Command, args []string) error {
		name, err := getName()
		if err != nil {
			return err
		}

		run := genny.WetRunner(context.Background())
		g, err := packages.New(&packages.Options{
			Name: flect.New(name),
		})
		if err != nil {
			return err
		}
		run.With(g)
		return run.Run()
	},
}

var ScaffoldCmd = &cobra.Command{
	Use:              "scaffold",
	Short:            "Generate scaffold for model",
	Example:          "dashi generate scaffold Post title:string content:text",
	TraverseChildren: true,
	Args:             cobra.MinimumNArgs(2),
	RunE: func(cmd *cobra.Command, args []string) error {
		gg := &genny.Group{}
		run := genny.WetRunner(context.Background())
		run.Logger = logger.New(logger.DebugLevel)
		run.Logger.Infof("Generating new scaffold")

		opts, err := getOptions(args)
		if err != nil {
			return err
		}

		mops := &model.Options{
			Name:                   opts.Name,
			Attrs:                  opts.Attrs,
			Path:                   "models",
			Package:                "models",
			TestPackage:            "models",
			ForceDefaultID:         true,
			ForceDefaultTimestamps: true,
		}
		if err := mops.Validate(); err != nil {
			return err
		}

		modelGen, err := model.New(mops)
		if err != nil {
			return err
		}
		modelGen.Command(exec.Command("go", "get", "./models"))
		gg.Add(modelGen)

		schemaGen, err := schema.New(&scaffold.Options{
			Name:  opts.Name,
			Attrs: mops.Attrs,
		})
		if err != nil {
			return err
		}
		gg.Add(schemaGen)

		migrationGen, err := migration.New(&migration.Options{
			Dialect: "postgres",
			Name:    opts.Name,
			Time:    GetTime(),
			Attrs:   mops.Attrs,
		})
		if err != nil {
			return err
		}
		gg.Add(migrationGen)

		graphqlGen, err := graphql.New()
		if err != nil {
			return err
		}
		gg.Add(graphqlGen)

		dashboardGen, err := dashboard.New(opts)
		if err != nil {
			return err
		}
		gg.Add(dashboardGen)

		fmt := genny.New()
		fmt.RunFn(func(r *genny.Runner) error {
			r.Exec(exec.Command("make", "fmt"))
			return nil
		})
		gg.Add(fmt)

		run.WithGroup(gg)
		return run.Run()
	},
}

var ScaffoldDashboardCmd = &cobra.Command{
	Use:     "scaffold:dashboard",
	Short:   "Generate scaffold for dashboard",
	Example: "dashi generate scaffold:dashboard Post title:string content:text",
	RunE: func(cmd *cobra.Command, args []string) error {
		gg := &genny.Group{}
		run := genny.WetRunner(context.Background())
		run.Logger = logger.New(logger.DebugLevel)

		opts, err := getOptions(args)
		if err != nil {
			return err
		}

		dashboardGen, err := dashboard.New(opts)
		if err != nil {
			return err
		}
		gg.Add(dashboardGen)

		fmt := genny.New()
		fmt.RunFn(func(r *genny.Runner) error {
			r.Exec(exec.Command("make", "fmt"))
			return nil
		})
		gg.Add(fmt)

		run.WithGroup(gg)
		return run.Run()
	},
}

Functions

func GetTime

func GetTime() string