gqlgen: github.com/99designs/gqlgen/plugin/modelgen/out Index | Files

package out

import "github.com/99designs/gqlgen/plugin/modelgen/out"

Index

Package Files

existing.go generated.go

Variables

var AllEnumWithDescription = []EnumWithDescription{
    EnumWithDescriptionCat,
    EnumWithDescriptionDog,
}
var AllMissingEnum = []MissingEnum{
    MissingEnumHello,
    MissingEnumGoodbye,
}

type EnumWithDescription Uses

type EnumWithDescription string

EnumWithDescription is an enum with a description

const (
    EnumWithDescriptionCat EnumWithDescription = "CAT"
    EnumWithDescriptionDog EnumWithDescription = "DOG"
)

func (EnumWithDescription) IsValid Uses

func (e EnumWithDescription) IsValid() bool

func (EnumWithDescription) MarshalGQL Uses

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

func (EnumWithDescription) String Uses

func (e EnumWithDescription) String() string

func (*EnumWithDescription) UnmarshalGQL Uses

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

type ExistingEnum Uses

type ExistingEnum string

type ExistingInput Uses

type ExistingInput struct {
    Name string
    Enum ExistingEnum
    Int  ExistingInterface
}

type ExistingInterface Uses

type ExistingInterface interface {
    IsExistingInterface()
}

type ExistingModel Uses

type ExistingModel struct {
    Name string
    Enum ExistingEnum
    Int  ExistingInterface
}

type ExistingType Uses

type ExistingType struct {
    Name     *string              `json:"name"`
    Enum     *ExistingEnum        `json:"enum"`
    Int      ExistingInterface    `json:"int"`
    Existing *MissingTypeNullable `json:"existing"`
}

type ExistingUnion Uses

type ExistingUnion interface {
    IsExistingUnion()
}

type FooBarer Uses

type FooBarer interface {
    IsFooBarer()
}

type FooBarr Uses

type FooBarr struct {
    Name string `json:"name" database:"_Foo_Barrname"`
}

func (FooBarr) IsFooBarer Uses

func (FooBarr) IsFooBarer()

type InterfaceWithDescription Uses

type InterfaceWithDescription interface {
    IsInterfaceWithDescription()
}

InterfaceWithDescription is an interface with a description

type MissingEnum Uses

type MissingEnum string
const (
    MissingEnumHello   MissingEnum = "Hello"
    MissingEnumGoodbye MissingEnum = "Goodbye"
)

func (MissingEnum) IsValid Uses

func (e MissingEnum) IsValid() bool

func (MissingEnum) MarshalGQL Uses

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

func (MissingEnum) String Uses

func (e MissingEnum) String() string

func (*MissingEnum) UnmarshalGQL Uses

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

type MissingInput Uses

type MissingInput struct {
    Name *string      `json:"name" database:"MissingInputname"`
    Enum *MissingEnum `json:"enum" database:"MissingInputenum"`
}

type MissingInterface Uses

type MissingInterface interface {
    IsMissingInterface()
}

type MissingTypeNotNull Uses

type MissingTypeNotNull struct {
    Name     string               `json:"name" database:"MissingTypeNotNullname"`
    Enum     MissingEnum          `json:"enum" database:"MissingTypeNotNullenum"`
    Int      MissingInterface     `json:"int" database:"MissingTypeNotNullint"`
    Existing *ExistingType        `json:"existing" database:"MissingTypeNotNullexisting"`
    Missing2 *MissingTypeNullable `json:"missing2" database:"MissingTypeNotNullmissing2"`
}

func (MissingTypeNotNull) IsExistingInterface Uses

func (MissingTypeNotNull) IsExistingInterface()

func (MissingTypeNotNull) IsExistingUnion Uses

func (MissingTypeNotNull) IsExistingUnion()

func (MissingTypeNotNull) IsMissingInterface Uses

func (MissingTypeNotNull) IsMissingInterface()

func (MissingTypeNotNull) IsMissingUnion Uses

func (MissingTypeNotNull) IsMissingUnion()

type MissingTypeNullable Uses

type MissingTypeNullable struct {
    Name     *string             `json:"name" database:"MissingTypeNullablename"`
    Enum     *MissingEnum        `json:"enum" database:"MissingTypeNullableenum"`
    Int      MissingInterface    `json:"int" database:"MissingTypeNullableint"`
    Existing *ExistingType       `json:"existing" database:"MissingTypeNullableexisting"`
    Missing2 *MissingTypeNotNull `json:"missing2" database:"MissingTypeNullablemissing2"`
}

func (MissingTypeNullable) IsExistingInterface Uses

func (MissingTypeNullable) IsExistingInterface()

func (MissingTypeNullable) IsExistingUnion Uses

func (MissingTypeNullable) IsExistingUnion()

func (MissingTypeNullable) IsMissingInterface Uses

func (MissingTypeNullable) IsMissingInterface()

func (MissingTypeNullable) IsMissingUnion Uses

func (MissingTypeNullable) IsMissingUnion()

type MissingUnion Uses

type MissingUnion interface {
    IsMissingUnion()
}

type TypeWithDescription Uses

type TypeWithDescription struct {
    Name *string `json:"name" database:"TypeWithDescriptionname"`
}

TypeWithDescription is a type with a description

func (TypeWithDescription) IsUnionWithDescription Uses

func (TypeWithDescription) IsUnionWithDescription()

type UnionWithDescription Uses

type UnionWithDescription interface {
    IsUnionWithDescription()
}

UnionWithDescription is an union with a description

Package out imports 3 packages (graph). Updated 2020-03-09. Refresh now. Tools for package owners.