gbgen

package module
v3.0.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 3, 2020 License: MIT Imports: 29 Imported by: 0

README

gqlgen-sqlboiler

We want developers to be able to build software faster using modern tools like GraphQL, Golang, React Native without depending on commercial providers like Firebase or AWS Amplify.

This program generates type-safe code between your generated gqlgen and sqlboiler models with support for unique id's across your whole database (also if you're not using string id's). We can automatically generate the implementation of queries and mutations like create, update, delete based on your graphql scheme and your sqlboiler models.

To make this program a success coupling (same naming) between your database and graphql scheme is needed at the moment. The advantage of this program is the most when you have a database already designed. However everything is created with support for change so you could write some extra GrapQL resolvers if you'd like without a problem.

Why gqlgen and sqlboiler

They go back to a schema first approach which we like. The generated code with these tools are the most efficient and fast in the Golang system (and probably outside of it too).

It's really amazing how fast a generated api with these techniques is!

Usage

  1. Generate database structs with: https://github.com/volatiletech/sqlboiler (--no-back-referencing is IMPORTANT!) e.g. sqlboiler mysql --no-back-referencing
  2. Generate gqlgen structs + converts between gqlgen and sqlboiler with this program
    e.g. go run convert_plugin.go for file contents of that program see bottom of this readme you can chose whether to generate the graphql schema itself too

Features

  • Generate graphql.schema based on sqlboiler structs
  • Generate converts between sqlboiler structs and graphql (with relations included)
  • Generate converts between input models and sqlboiler
  • Genarated code understands the difference between empty and null for update inputs so you can set things empty if you explicicitly set them in your mutation!
  • Fetch sqlboiler preloads from graphql context
  • Support for foreign keys named differently than their corresponding model
  • New plugin which generates CRUD resolvers based on mutations in graphql scheme.
  • Support one-to-one relationships inside input types.
  • Generate code which implements the generated where and search filters
  • Batch update/delete generation in resolvers (Not tested yet).
  • Enum support.
  • public errors in resolvers + logging via zerolog. (feel free for PR for configurable logging!)

v3.0

  • Edges/connections
  • Type safe sorting

Roadmap v3.1

  • Support gqlgen multiple .graphql files
  • Support for opting out of standard generation if functions exist in {resolverName}_custom.go

Roadmap v3.2

Examples

https://github.com/web-ridge/gqlgen-sqlboiler-examples

More examples are welcome. Send a PR ;-)

Example result of this plugin

https://github.com/web-ridge/gqlgen-sqlboiler-examples/tree/master/social-network/helpers

Code snippet

func PostToGraphQL(m *models.Post) *graphql_models.Post {
	if m == nil {
		return nil
	}

	r := &graphql_models.Post{
		ID:      PostIDToGraphQL(m.ID),
		Content: m.Content,
	}

	if boilergql.UintIsFilled(m.UserID) {
		if m.R != nil && m.R.User != nil {
			r.User = UserToGraphQL(m.R.User)
		} else {
			r.User = UserWithUintID(m.UserID)
		}
	}
	if m.R != nil && m.R.Comments != nil {
		r.Comments = CommentsToGraphQL(m.R.Comments)
	}
	if m.R != nil && m.R.Images != nil {
		r.Images = ImagesToGraphQL(m.R.Images)
	}
	if m.R != nil && m.R.Likes != nil {
		r.Likes = LikesToGraphQL(m.R.Likes)
	}

	return r
}

sqlboiler.yml

mysql:
  dbname: dbname
  host: localhost
  port: 8889
  user: root
  pass: root
  sslmode: "false"
  blacklist:
    - notifications
    - jobs
    - password_resets
    - migrations
mysqldump:
  column-statistics: 0

gqlgen.yml

schema:
  - schema.graphql
exec:
  filename: graphql_models/generated.go
  package: graphql_models
model:
  filename: graphql_models/genereated_models.go
  package: graphql_models
resolver:
  filename: resolver.go
  type: Resolver
models:
  ConnectionBackwardPagination:
    model: github.com/web-ridge/utils-go/boilergql/v3.ConnectionBackwardPagination
  ConnectionForwardPagination:
    model: github.com/web-ridge/utils-go/boilergql/v3.ConnectionForwardPagination
  ConnectionPagination:
    model: github.com/web-ridge/utils-go/boilergql/v3.ConnectionPagination
  SortDirection:
    model: github.com/web-ridge/utils-go/boilergql/v3.SortDirection

Put this in your program convert_plugin.go e.g.

// +build ignore

package main

import (
	"fmt"
	"os"

	"github.com/99designs/gqlgen/api"
	"github.com/99designs/gqlgen/codegen/config"
	gbgen "github.com/web-ridge/gqlgen-sqlboiler/v3"
)

func main() {
	cfg, err := config.LoadConfigFromDefaultLocations()
	if err != nil {
		fmt.Fprintln(os.Stderr, "failed to load config", err.Error())
		os.Exit(2)
	}

	output := gbgen.Config{
		Directory:   "helpers", // supports root or sub directories
		PackageName: "helpers",
	}
	backend := gbgen.Config{
		Directory:   "models",
		PackageName: "models",
	}
	frontend := gbgen.Config{
		Directory:   "graphql_models",
		PackageName: "graphql_models",
	}

	if err = gbgen.SchemaWrite(gbgen.SchemaConfig{
		BoilerModelDirectory: backend,
		// Directives:           []string{"IsAuthenticated"},
		// GenerateBatchCreate:  false, // Not implemented yet
		GenerateMutations:    true,
		GenerateBatchDelete:  true,
		GenerateBatchUpdate:  true,
	}, "schema.graphql", gbgen.SchemaGenerateConfig{
		MergeSchema: false, // uses three way merge to keep your customization
	}); err != nil {
		fmt.Println("error while trying to generate schema.graphql")
		fmt.Fprintln(os.Stderr, err.Error())
		os.Exit(3)
	}

	if err = api.Generate(cfg,
		api.AddPlugin(gbgen.NewConvertPlugin(
			output,   // directory where convert.go, convert_input.go and preload.go should live
			backend,  // directory where sqlboiler files are put
			frontend, // directory where gqlgen models live
			gbgen.ConvertPluginConfig{
				// UseReflectWorkaroundForSubModelFilteringInPostgresIssue25: true, // see issue #25 on GitHub
			},
		)),
		api.AddPlugin(gbgen.NewResolverPlugin(
			output,
			backend,
			frontend,
			"", // leave empty if you don't have auth
		)),
	); err != nil {
		fmt.Println("error while trying generate resolver and converts")
		fmt.Fprintln(os.Stderr, err.Error())
		os.Exit(3)
	}
}

go run convert_plugin.go

Help us

We're the most happy with your time investments and/or pull request to improve this plugin. Feedback is also highly appreciated.

If you don't have time or knowledge to contribute and we did save you a lot of time, please consider a donation so we can invest more time in this library: paypal

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var InputTypes = []string{"Create", "Update", "Delete"} //nolint:gochecknoglobals

Functions

func NameForDir 

func NameForDir(dir string) string

NameForDir manually looks for package stanzas in files located in the given directory. This can be much faster than having to consult go list, because we already know exactly where to look.

func NewConvertPlugin 

func NewConvertPlugin(output, backend, frontend Config, pluginConfig ConvertPluginConfig) plugin.Plugin

func NewResolverPlugin 

func NewResolverPlugin(output, backend, frontend Config, authImport string) plugin.Plugin

func PkgAndType 

func PkgAndType(name string) (string, string)

take a string in the form github.com/package/blah.Type and split it into package and type

func SanitizePackageName 

func SanitizePackageName(pkg string) string

func SchemaGet 

func SchemaGet(
	config SchemaConfig,
) string

func SchemaWrite 

func SchemaWrite(config SchemaConfig, outputFile string, generateOptions SchemaGenerateConfig) error

Types

type BoilerField 

type BoilerField struct {
	Name             string
	PluralName       string
	Type             string
	IsForeignKey     bool
	IsRequired       bool
	IsArray          bool
	IsRelation       bool
	RelationshipName string
	Relationship     *BoilerModel
}

type BoilerModel 

type BoilerModel struct {
	Name                  string
	TableName             string
	PluralName            string
	Fields                []*BoilerField
	HasOrganizationID     bool
	HasUserOrganizationID bool
	HasUserID             bool
	HasPrimaryStringID    bool
}

func FindBoilerModel 

func FindBoilerModel(models []*BoilerModel, modelName string) *BoilerModel

func GetBoilerModels 

func GetBoilerModels(dir string) []*BoilerModel

parseModelsAndFieldsFromBoiler since these are like User.ID, User.Organization and we want them grouped by modelName and their belonging fields.

type BoilerType 

type BoilerType struct {
	Name string
	Type string
}

type ColumnSetting 

type ColumnSetting struct {
	Name                  string
	RelationshipModelName string
	IDAvailable           bool
}

type Config 

type Config struct {
	Directory   string
	PackageName string
}

type ConvertConfig 

type ConvertConfig struct {
	IsCustom         bool
	ToBoiler         string
	ToGraphQL        string
	GraphTypeAsText  string
	BoilerTypeAsText string
}

type ConvertPlugin 

type ConvertPlugin struct {
	Output       Config
	Backend      Config
	Frontend     Config
	PluginConfig ConvertPluginConfig
	// contains filtered or unexported fields
}

func (*ConvertPlugin) MutateConfig 

func (m *ConvertPlugin) MutateConfig(originalCfg *config.Config) error

func (*ConvertPlugin) Name 

func (m *ConvertPlugin) Name() string

type ConvertPluginConfig 

type ConvertPluginConfig struct {
	UseReflectWorkaroundForSubModelFilteringInPostgresIssue25 bool
}

type Enum 

type Enum struct {
	Description string
	Name        string

	Values []*EnumValue
}

type EnumValue 

type EnumValue struct {
	Description string
	Name        string
	NameLower   string
}

type Field 

type Field struct {
	Name               string
	JSONName           string
	PluralName         string
	Type               string
	TypeWithoutPointer string
	IsNumberID         bool
	IsPrimaryNumberID  bool
	IsPrimaryStringID  bool
	IsPrimaryID        bool
	IsRequired         bool
	IsPlural           bool
	ConvertConfig      ConvertConfig
	Enum               *Enum
	// relation stuff
	IsRelation bool
	// boiler relation stuff is inside this field
	BoilerField BoilerField
	// graphql relation ship can be found here
	Relationship *Model
	IsOr         bool
	IsAnd        bool

	// Some stuff
	Description  string
	OriginalType types.Type
}

type File 

type File struct {
	// These are separated because the type definition of the resolver object may live in a different file from the
	// resolver method implementations, for example when extending a type in a different graphql schema file
	Objects   []*codegen.Object
	Resolvers []*Resolver

	RemainingSource string
	// contains filtered or unexported fields
}

func (*File) Imports 

func (f *File) Imports() string

type Import 

type Import struct {
	Alias      string
	ImportPath string
}

type Interface 

type Interface struct {
	Description string
	Name        string
}

type Model 

type Model struct {
	Name                  string
	PluralName            string
	BoilerModel           *BoilerModel
	PrimaryKeyType        string
	Fields                []*Field
	IsNormal              bool
	IsInput               bool
	IsCreateInput         bool
	IsUpdateInput         bool
	IsNormalInput         bool
	IsPayload             bool
	IsConnection          bool
	IsEdge                bool
	IsOrdering            bool
	IsWhere               bool
	IsFilter              bool
	IsPreloadable         bool
	PreloadArray          []Preload
	HasOrganizationID     bool // TODO: something more pluggable
	HasUserOrganizationID bool // TODO: something more pluggable
	HasUserID             bool // TODO: something more pluggable
	HasPrimaryStringID    bool
	// other stuff
	Description string
	PureFields  []*ast.FieldDefinition
	Implements  []string
}

func GetModelsWithInformation 

func GetModelsWithInformation(backend Config, enums []*Enum, cfg *config.Config, boilerModels []*BoilerModel) []*Model

type ModelBuild 

type ModelBuild struct {
	Backend      Config
	Frontend     Config
	PluginConfig ConvertPluginConfig
	PackageName  string
	Interfaces   []*Interface
	Models       []*Model
	Enums        []*Enum
	Scalars      []string
}

type Preload 

type Preload struct {
	Key           string
	ColumnSetting ColumnSetting
}

type Resolver 

type Resolver struct {
	Object                    *codegen.Object
	Field                     *codegen.Field
	Implementation            string
	IsSingle                  bool
	IsList                    bool
	IsCreate                  bool
	IsUpdate                  bool
	IsDelete                  bool
	IsBatchCreate             bool
	IsBatchUpdate             bool
	IsBatchDelete             bool
	BoilerWhiteList           string
	ResolveOrganizationID     bool // TODO: something more pluggable
	ResolveUserOrganizationID bool // TODO: something more pluggable
	ResolveUserID             bool // TODO: something more pluggable
	Model                     Model
	InputModel                Model

	PublicErrorKey     string
	PublicErrorMessage string
}

type ResolverBuild 

type ResolverBuild struct {
	*File
	HasAuth      bool
	HasRoot      bool
	PackageName  string
	ResolverType string
	Models       []*Model
}

type ResolverPlugin 

type ResolverPlugin struct {
	// contains filtered or unexported fields
}

func (*ResolverPlugin) GenerateCode 

func (m *ResolverPlugin) GenerateCode(data *codegen.Data) error

func (*ResolverPlugin) Name 

func (m *ResolverPlugin) Name() string

type Rewriter 

type Rewriter struct {
	// contains filtered or unexported fields
}

func NewRewriter 

func NewRewriter(importPath string) (*Rewriter, error)

func (*Rewriter) ExistingImports 

func (r *Rewriter) ExistingImports(filename string) []Import

func (*Rewriter) GetMethodBody 

func (r *Rewriter) GetMethodBody(structname string, methodname string) string

func (*Rewriter) MarkStructCopied 

func (r *Rewriter) MarkStructCopied(name string)

func (*Rewriter) RemainingSource 

func (r *Rewriter) RemainingSource(filename string) string

type SchemaConfig 

type SchemaConfig struct {
	BoilerModelDirectory Config
	Directives           []string
	SkipInputFields      []string
	GenerateBatchCreate  bool
	GenerateMutations    bool
	GenerateBatchDelete  bool
	GenerateBatchUpdate  bool
}

type SchemaField 

type SchemaField struct {
	Name             string
	Type             string // String, ID, Integer
	RelationName     string // posts
	RelationType     string // Page, User, Post
	FullType         string // e.g String! or if array [String!]
	RelationFullType string // [Posts!]
	FullTypeOptional string // e.g. String or if array [String]
	BoilerField      *BoilerField
}

type SchemaGenerateConfig 

type SchemaGenerateConfig struct {
	MergeSchema bool
}

type SchemaModel 

type SchemaModel struct {
	Name   string
	Fields []*SchemaField
}

type SimpleWriter 

type SimpleWriter struct {
	// contains filtered or unexported fields
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.