gbgen

package module
v3.1.0 Latest Latest
Warning

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

 Go to latest Published: Dec 30, 2020 License: MIT Imports: 26 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
  • Three-way-merge with your old schema so you can easily keep your own changes
  • 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 input, so you can set things empty if you explicitly set them in your mutation!
  • Fetch sqlboiler preloads from graphql context
  • Support for foreign keys and relations
  • Plugin which generates CRUD resolvers based on queries/mutations in graphql schema.
  • Support one-to-one relationships inside input types.
  • Generate code which implements the generated where and search filters
  • Batch update/delete generation in resolvers.
  • Enum support (only in graphql schema right now).
  • public errors in resolvers + logging via zerolog.

v3.0

  • Edges/connections
  • Type safe sorting

Roadmap v3.1

  • Support for overriding convert functions with your custom resolvers (see example here: )
  • RESOLVER TODO

Roadmap v3.2

  • Support gqlgen multiple .graphql files
  • Support multiple resolvers (per schema)

Roadmap v3.3

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 NewConvertPlugin 

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

func NewResolverPlugin 

func NewResolverPlugin(output, backend, frontend Config, resolverPluginConfig ResolverPluginConfig) plugin.Plugin

func SchemaGet 

func SchemaGet(
	config SchemaConfig,
) string

func SchemaWrite 

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

Types

type AuthorizationScope added in v3.1.0 

type AuthorizationScope struct {
	ImportPath        string
	ImportAlias       string
	ScopeResolverName string
	BoilerColumnName  string
	AddHook           func(model *BoilerModel, resolver *Resolver, templateKey string) bool
}

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
	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
	IsObject   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
	Imports         []Import
	RemainingSource 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

	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
	IsListForward             bool
	IsListBackward            bool
	IsCreate                  bool
	IsUpdate                  bool
	IsDelete                  bool
	IsBatchCreate             bool
	IsBatchUpdate             bool
	IsBatchDelete             bool
	ResolveOrganizationID     bool // TODO: something more pluggable
	ResolveUserOrganizationID bool // TODO: something more pluggable
	ResolveUserID             bool // TODO: something more pluggable
	Model                     Model
	InputModel                Model
	BoilerWhiteList           string
	PublicErrorKey            string
	PublicErrorMessage        string
}

type ResolverBuild 

type ResolverBuild struct {
	*File
	HasRoot             bool
	PackageName         string
	ResolverType        string
	Models              []*Model
	AuthorizationScopes []*AuthorizationScope
	TryHook             func(string) bool
}

func (*ResolverBuild) ShortResolverDeclaration added in v3.1.0 

func (rb *ResolverBuild) ShortResolverDeclaration(r *Resolver) string

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 ResolverPluginConfig added in v3.1.0 

type ResolverPluginConfig struct {
	AuthorizationScopes []*AuthorizationScope
}

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

Directories

Path Synopsis

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.