model

Documentation

Index

• Variables
• type AggregateResult
• type BooleanComparator
• type BooleanListComparator
• type CategoriesAggregate
• type Category
• type CategoryFilterInput
• type CategoryMin
• type CategoryOrdering
• type CreatePostInput
• type IntComparator
• type IntListComparator
• type ManyToManyRelation
• type OrderingTypes
  • func (e OrderingTypes) IsValid() bool
  • func (e OrderingTypes) MarshalGQL(w io.Writer)
  • func (e OrderingTypes) String() string
  • func (e *OrderingTypes) UnmarshalGQL(v interface{}) error
• type Post
• type PostFilterInput
• type PostMin
• type PostOrdering
• type PostsAggregate
• type PostsPayload
• type RelationType
  • func (e RelationType) IsValid() bool
  • func (e RelationType) MarshalGQL(w io.Writer)
  • func (e RelationType) String() string
  • func (e *RelationType) UnmarshalGQL(v interface{}) error
• type StringComparator
• type StringListComparator
• type UpdatePostInput
• type User
• type UserFilterInput
• type UserMin
• type UserOrdering
• type UsersAggregate

Variables

var AllOrderingTypes = []OrderingTypes{
	OrderingTypesAsc,
	OrderingTypesDesc,
	OrderingTypesAscNullFirst,
	OrderingTypesDescNullFirst,
}

var AllRelationType = []RelationType{
	RelationTypeOneToOne,
	RelationTypeOneToMany,
	RelationTypeManyToMany,
}

Types

type AggregateResult

type AggregateResult struct {
	Count int `json:"count" db:"count"`
}

type BooleanComparator

type BooleanComparator struct {
	Eq     *bool `json:"eq" db:"eq"`
	Neq    *bool `json:"neq" db:"neq"`
	IsNull *bool `json:"isNull" db:"isNull"`
}

type BooleanListComparator

type BooleanListComparator struct {
	Eq        []*bool `json:"eq" db:"eq"`
	Neq       []*bool `json:"neq" db:"neq"`
	Contains  []*bool `json:"contains" db:"contains"`
	Contained []*bool `json:"contained" db:"contained"`
	Overlap   []*bool `json:"overlap" db:"overlap"`
	IsNull    *bool   `json:"isNull" db:"isNull"`
}

type CategoriesAggregate

type CategoriesAggregate struct {
	// Count results
	Count int `json:"count" db:"count"`
	// Computes the maximum of the non-null input values.
	Max *CategoryMin `json:"max" db:"max"`
	// Computes the minimum of the non-null input values.
	Min *CategoryMin `json:"min" db:"min"`
}

Aggregate Category

type Category

type Category struct {
	ID   int     `json:"id" db:"id"`
	Name *string `json:"name" db:"name"`
}

type CategoryFilterInput

type CategoryFilterInput struct {
	ID   *IntComparator    `json:"id" db:"id"`
	Name *StringComparator `json:"name" db:"name"`
	// Logical AND of FilterInput
	And []*CategoryFilterInput `json:"AND" db:"AND"`
	// Logical OR of FilterInput
	Or []*CategoryFilterInput `json:"OR" db:"OR"`
	// Logical NOT of FilterInput
	Not *CategoryFilterInput `json:"NOT" db:"NOT"`
}

type CategoryMin

type CategoryMin struct {
	// Compute the maxiumum for id
	ID int `json:"id" db:"id"`
	// Compute the maxiumum for name
	Name string `json:"name" db:"name"`
}

max aggregator for Category

type CategoryOrdering

type CategoryOrdering struct {
	// Order Category by id
	ID *OrderingTypes `json:"id" db:"id"`
	// Order Category by name
	Name *OrderingTypes `json:"name" db:"name"`
}

Ordering for Category

type CreatePostInput

type CreatePostInput struct {
	ID   int     `json:"id" db:"id"`
	Name *string `json:"name" db:"name"`
}

AutoGenerated input for Post

type IntComparator

type IntComparator struct {
	Eq     *int  `json:"eq" db:"eq"`
	Neq    *int  `json:"neq" db:"neq"`
	Gt     *int  `json:"gt" db:"gt"`
	Gte    *int  `json:"gte" db:"gte"`
	Lt     *int  `json:"lt" db:"lt"`
	Lte    *int  `json:"lte" db:"lte"`
	IsNull *bool `json:"isNull" db:"isNull"`
}

type IntListComparator

type IntListComparator struct {
	Eq        []*int `json:"eq" db:"eq"`
	Neq       []*int `json:"neq" db:"neq"`
	Contains  []*int `json:"contains" db:"contains"`
	Contained []*int `json:"contained" db:"contained"`
	Overlap   []*int `json:"overlap" db:"overlap"`
	IsNull    *bool  `json:"isNull" db:"isNull"`
}

type ManyToManyRelation

type ManyToManyRelation struct {
	Table      *string   `json:"table" db:"table"`
	Fields     []*string `json:"fields" db:"fields"`
	References []*string `json:"references" db:"references"`
}

type OrderingTypes

type OrderingTypes string

const (
	OrderingTypesAsc           OrderingTypes = "ASC"
	OrderingTypesDesc          OrderingTypes = "DESC"
	OrderingTypesAscNullFirst  OrderingTypes = "ASC_NULL_FIRST"
	OrderingTypesDescNullFirst OrderingTypes = "DESC_NULL_FIRST"
)

func (OrderingTypes) IsValid

func (e OrderingTypes) IsValid() bool

func (OrderingTypes) MarshalGQL

func (e OrderingTypes) MarshalGQL(w io.Writer)

func (OrderingTypes) String

func (e OrderingTypes) String() string

func (*OrderingTypes) UnmarshalGQL

func (e *OrderingTypes) UnmarshalGQL(v interface{}) error

type Post

type Post struct {
	ID         int         `json:"id" db:"id"`
	Name       *string     `json:"name" db:"name"`
	Categories []*Category `json:"categories" db:"categories"`
	User       *User       `json:"user" db:"user"`
	// categories Aggregate
	CategoriesAggregate *CategoriesAggregate `json:"_categoriesAggregate" db:"_categoriesAggregate"`
}

type PostFilterInput

type PostFilterInput struct {
	ID         *IntComparator       `json:"id" db:"id"`
	Name       *StringComparator    `json:"name" db:"name"`
	Categories *CategoryFilterInput `json:"categories" db:"categories"`
	User       *UserFilterInput     `json:"user" db:"user"`
	// Logical AND of FilterInput
	And []*PostFilterInput `json:"AND" db:"AND"`
	// Logical OR of FilterInput
	Or []*PostFilterInput `json:"OR" db:"OR"`
	// Logical NOT of FilterInput
	Not *PostFilterInput `json:"NOT" db:"NOT"`
}

type PostMin

type PostMin struct {
	// Compute the maxiumum for id
	ID int `json:"id" db:"id"`
	// Compute the maxiumum for name
	Name string `json:"name" db:"name"`
}

max aggregator for Post

type PostOrdering

type PostOrdering struct {
	// Order Post by id
	ID *OrderingTypes `json:"id" db:"id"`
	// Order Post by name
	Name *OrderingTypes `json:"name" db:"name"`
}

Ordering for Post

type PostsAggregate

type PostsAggregate struct {
	// Count results
	Count int `json:"count" db:"count"`
	// Computes the maximum of the non-null input values.
	Max *PostMin `json:"max" db:"max"`
	// Computes the minimum of the non-null input values.
	Min *PostMin `json:"min" db:"min"`
}

Aggregate Post

type PostsPayload

type PostsPayload struct {
	// rows affection by mutation
	RowsAffected int     `json:"rows_affected" db:"rows_affected"`
	Posts        []*Post `json:"posts" db:"posts"`
}

Autogenerated payload object

type RelationType

type RelationType string

const (
	RelationTypeOneToOne   RelationType = "ONE_TO_ONE"
	RelationTypeOneToMany  RelationType = "ONE_TO_MANY"
	RelationTypeManyToMany RelationType = "MANY_TO_MANY"
)

func (RelationType) IsValid

func (e RelationType) IsValid() bool

func (RelationType) MarshalGQL

func (e RelationType) MarshalGQL(w io.Writer)

func (RelationType) String

func (e RelationType) String() string

func (*RelationType) UnmarshalGQL

func (e *RelationType) UnmarshalGQL(v interface{}) error

type StringComparator

type StringComparator struct {
	Eq          *string   `json:"eq" db:"eq"`
	Neq         *string   `json:"neq" db:"neq"`
	Contains    []*string `json:"contains" db:"contains"`
	NotContains []*string `json:"notContains" db:"notContains"`
	Like        *string   `json:"like" db:"like"`
	Ilike       *string   `json:"ilike" db:"ilike"`
	Suffix      *string   `json:"suffix" db:"suffix"`
	Prefix      *string   `json:"prefix" db:"prefix"`
	IsNull      *bool     `json:"isNull" db:"isNull"`
}

type StringListComparator

type StringListComparator struct {
	Eq          []*string `json:"eq" db:"eq"`
	Neq         []*string `json:"neq" db:"neq"`
	Contains    []*string `json:"contains" db:"contains"`
	ContainedBy []*string `json:"containedBy" db:"containedBy"`
	Overlap     []*string `json:"overlap" db:"overlap"`
	IsNull      *bool     `json:"isNull" db:"isNull"`
}

type UpdatePostInput

type UpdatePostInput struct {
	ID   *int    `json:"id" db:"id"`
	Name *string `json:"name" db:"name"`
}

AutoGenerated update input for Post

type User

type User struct {
	ID    int     `json:"id" db:"id"`
	Name  string  `json:"name" db:"name"`
	Posts []*Post `json:"posts" db:"posts"`
	// posts Aggregate
	PostsAggregate *PostsAggregate `json:"_postsAggregate" db:"_postsAggregate"`
}

type UserFilterInput

type UserFilterInput struct {
	ID    *IntComparator    `json:"id" db:"id"`
	Name  *StringComparator `json:"name" db:"name"`
	Posts *PostFilterInput  `json:"posts" db:"posts"`
	// Logical AND of FilterInput
	And []*UserFilterInput `json:"AND" db:"AND"`
	// Logical OR of FilterInput
	Or []*UserFilterInput `json:"OR" db:"OR"`
	// Logical NOT of FilterInput
	Not *UserFilterInput `json:"NOT" db:"NOT"`
}

type UserMin

type UserMin struct {
	// Compute the maxiumum for id
	ID int `json:"id" db:"id"`
	// Compute the maxiumum for name
	Name string `json:"name" db:"name"`
}

max aggregator for User

type UserOrdering

type UserOrdering struct {
	// Order User by id
	ID *OrderingTypes `json:"id" db:"id"`
	// Order User by name
	Name *OrderingTypes `json:"name" db:"name"`
}

Ordering for User

type UsersAggregate

type UsersAggregate struct {
	// Count results
	Count int `json:"count" db:"count"`
	// Computes the maximum of the non-null input values.
	Max *UserMin `json:"max" db:"max"`
	// Computes the minimum of the non-null input values.
	Min *UserMin `json:"min" db:"min"`
}

Aggregate User