@@ 0,0 1,5213 @@
+// Code generated by github.com/99designs/gqlgen, DO NOT EDIT.
+
+package api
+
+import (
+ "bytes"
+ "context"
+ "errors"
+ "fmt"
+ "math"
+ "strconv"
+ "sync/atomic"
+ "time"
+
+ "github.com/99designs/gqlgen/graphql"
+ "github.com/99designs/gqlgen/graphql/introspection"
+ gqlparser "github.com/vektah/gqlparser/v2"
+ "github.com/vektah/gqlparser/v2/ast"
+ "sourcecraft.dev/bigbes/sr-ht-core/model"
+ model1 "sourcecraft.dev/bigbes/sr-ht-dolt/graph/model"
+)
+
+// region ***************************** api!.gotpl *****************************
+
+// NewExecutableSchema creates an ExecutableSchema from the ResolverRoot interface.
+func NewExecutableSchema(cfg Config) graphql.ExecutableSchema {
+ return &executableSchema{SchemaData: cfg.Schema, Resolvers: cfg.Resolvers, Directives: cfg.Directives, ComplexityRoot: cfg.Complexity}
+}
+
+type Config = graphql.Config[ResolverRoot, DirectiveRoot, ComplexityRoot]
+
+type ResolverRoot interface {
+ Database() DatabaseResolver
+ Query() QueryResolver
+}
+
+type DirectiveRoot struct {
+}
+
+type ComplexityRoot struct {
+ ACLEntry struct {
+ Mode func(childComplexity int) int
+ User func(childComplexity int) int
+ }
+
+ Branch struct {
+ Head func(childComplexity int) int
+ Name func(childComplexity int) int
+ }
+
+ Column struct {
+ Name func(childComplexity int) int
+ Nullable func(childComplexity int) int
+ PrimaryKey func(childComplexity int) int
+ Type func(childComplexity int) int
+ }
+
+ Commit struct {
+ Author func(childComplexity int) int
+ Date func(childComplexity int) int
+ Email func(childComplexity int) int
+ Hash func(childComplexity int) int
+ Message func(childComplexity int) int
+ Parents func(childComplexity int) int
+ }
+
+ CommitCursor struct {
+ Cursor func(childComplexity int) int
+ Results func(childComplexity int) int
+ }
+
+ Database struct {
+ ACL func(childComplexity int) int
+ Branches func(childComplexity int) int
+ Created func(childComplexity int) int
+ DefaultBranch func(childComplexity int) int
+ Description func(childComplexity int) int
+ ID func(childComplexity int) int
+ Log func(childComplexity int, ref *string, from *model.Cursor, limit *int) int
+ Name func(childComplexity int) int
+ Owner func(childComplexity int) int
+ Tables func(childComplexity int, ref *string) int
+ Updated func(childComplexity int) int
+ Visibility func(childComplexity int) int
+ }
+
+ DatabaseCursor struct {
+ Cursor func(childComplexity int) int
+ Results func(childComplexity int) int
+ }
+
+ Query struct {
+ Database func(childComplexity int, owner string, name string) int
+ Databases func(childComplexity int, cursor *model.Cursor, filter *model.Filter) int
+ DatabasesByOwner func(childComplexity int, owner string, cursor *model.Cursor, filter *model.Filter) int
+ Me func(childComplexity int) int
+ }
+
+ Table struct {
+ Columns func(childComplexity int) int
+ Name func(childComplexity int) int
+ RowCount func(childComplexity int) int
+ }
+
+ User struct {
+ CanonicalName func(childComplexity int) int
+ Username func(childComplexity int) int
+ }
+}
+
+// endregion ***************************** api!.gotpl *****************************
+
+// region ************************** generated!.gotpl **************************
+
+type DatabaseResolver interface {
+ DefaultBranch(ctx context.Context, obj *model1.Database) (*string, error)
+ Branches(ctx context.Context, obj *model1.Database) ([]*model1.Branch, error)
+ Log(ctx context.Context, obj *model1.Database, ref *string, from *model.Cursor, limit *int) (*model1.CommitCursor, error)
+ Tables(ctx context.Context, obj *model1.Database, ref *string) ([]*model1.Table, error)
+ ACL(ctx context.Context, obj *model1.Database) ([]*model1.ACLEntry, error)
+}
+type QueryResolver interface {
+ Me(ctx context.Context) (*model1.User, error)
+ Databases(ctx context.Context, cursor *model.Cursor, filter *model.Filter) (*model1.DatabaseCursor, error)
+ DatabasesByOwner(ctx context.Context, owner string, cursor *model.Cursor, filter *model.Filter) (*model1.DatabaseCursor, error)
+ Database(ctx context.Context, owner string, name string) (*model1.Database, error)
+}
+
+// endregion ************************** generated!.gotpl **************************
+
+// region ************************** internal!.gotpl ***************************
+
+type executableSchema graphql.ExecutableSchemaState[ResolverRoot, DirectiveRoot, ComplexityRoot]
+
+func (e *executableSchema) Schema() *ast.Schema {
+ if e.SchemaData != nil {
+ return e.SchemaData
+ }
+ return parsedSchema
+}
+
+func (e *executableSchema) Complexity(ctx context.Context, typeName, field string, childComplexity int, rawArgs map[string]any) (int, bool) {
+ ec := newExecutionContext(nil, e, nil)
+ _ = ec
+ switch typeName + "." + field {
+
+ case "ACLEntry.mode":
+ if e.ComplexityRoot.ACLEntry.Mode == nil {
+ break
+ }
+
+ return e.ComplexityRoot.ACLEntry.Mode(childComplexity), true
+ case "ACLEntry.user":
+ if e.ComplexityRoot.ACLEntry.User == nil {
+ break
+ }
+
+ return e.ComplexityRoot.ACLEntry.User(childComplexity), true
+
+ case "Branch.head":
+ if e.ComplexityRoot.Branch.Head == nil {
+ break
+ }
+
+ return e.ComplexityRoot.Branch.Head(childComplexity), true
+ case "Branch.name":
+ if e.ComplexityRoot.Branch.Name == nil {
+ break
+ }
+
+ return e.ComplexityRoot.Branch.Name(childComplexity), true
+
+ case "Column.name":
+ if e.ComplexityRoot.Column.Name == nil {
+ break
+ }
+
+ return e.ComplexityRoot.Column.Name(childComplexity), true
+ case "Column.nullable":
+ if e.ComplexityRoot.Column.Nullable == nil {
+ break
+ }
+
+ return e.ComplexityRoot.Column.Nullable(childComplexity), true
+ case "Column.primaryKey":
+ if e.ComplexityRoot.Column.PrimaryKey == nil {
+ break
+ }
+
+ return e.ComplexityRoot.Column.PrimaryKey(childComplexity), true
+ case "Column.type":
+ if e.ComplexityRoot.Column.Type == nil {
+ break
+ }
+
+ return e.ComplexityRoot.Column.Type(childComplexity), true
+
+ case "Commit.author":
+ if e.ComplexityRoot.Commit.Author == nil {
+ break
+ }
+
+ return e.ComplexityRoot.Commit.Author(childComplexity), true
+ case "Commit.date":
+ if e.ComplexityRoot.Commit.Date == nil {
+ break
+ }
+
+ return e.ComplexityRoot.Commit.Date(childComplexity), true
+ case "Commit.email":
+ if e.ComplexityRoot.Commit.Email == nil {
+ break
+ }
+
+ return e.ComplexityRoot.Commit.Email(childComplexity), true
+ case "Commit.hash":
+ if e.ComplexityRoot.Commit.Hash == nil {
+ break
+ }
+
+ return e.ComplexityRoot.Commit.Hash(childComplexity), true
+ case "Commit.message":
+ if e.ComplexityRoot.Commit.Message == nil {
+ break
+ }
+
+ return e.ComplexityRoot.Commit.Message(childComplexity), true
+ case "Commit.parents":
+ if e.ComplexityRoot.Commit.Parents == nil {
+ break
+ }
+
+ return e.ComplexityRoot.Commit.Parents(childComplexity), true
+
+ case "CommitCursor.cursor":
+ if e.ComplexityRoot.CommitCursor.Cursor == nil {
+ break
+ }
+
+ return e.ComplexityRoot.CommitCursor.Cursor(childComplexity), true
+ case "CommitCursor.results":
+ if e.ComplexityRoot.CommitCursor.Results == nil {
+ break
+ }
+
+ return e.ComplexityRoot.CommitCursor.Results(childComplexity), true
+
+ case "Database.acl":
+ if e.ComplexityRoot.Database.ACL == nil {
+ break
+ }
+
+ return e.ComplexityRoot.Database.ACL(childComplexity), true
+ case "Database.branches":
+ if e.ComplexityRoot.Database.Branches == nil {
+ break
+ }
+
+ return e.ComplexityRoot.Database.Branches(childComplexity), true
+ case "Database.created":
+ if e.ComplexityRoot.Database.Created == nil {
+ break
+ }
+
+ return e.ComplexityRoot.Database.Created(childComplexity), true
+ case "Database.defaultBranch":
+ if e.ComplexityRoot.Database.DefaultBranch == nil {
+ break
+ }
+
+ return e.ComplexityRoot.Database.DefaultBranch(childComplexity), true
+ case "Database.description":
+ if e.ComplexityRoot.Database.Description == nil {
+ break
+ }
+
+ return e.ComplexityRoot.Database.Description(childComplexity), true
+ case "Database.id":
+ if e.ComplexityRoot.Database.ID == nil {
+ break
+ }
+
+ return e.ComplexityRoot.Database.ID(childComplexity), true
+ case "Database.log":
+ if e.ComplexityRoot.Database.Log == nil {
+ break
+ }
+
+ args, err := ec.field_Database_log_args(ctx, rawArgs)
+ if err != nil {
+ return 0, false
+ }
+
+ return e.ComplexityRoot.Database.Log(childComplexity, args["ref"].(*string), args["from"].(*model.Cursor), args["limit"].(*int)), true
+ case "Database.name":
+ if e.ComplexityRoot.Database.Name == nil {
+ break
+ }
+
+ return e.ComplexityRoot.Database.Name(childComplexity), true
+ case "Database.owner":
+ if e.ComplexityRoot.Database.Owner == nil {
+ break
+ }
+
+ return e.ComplexityRoot.Database.Owner(childComplexity), true
+ case "Database.tables":
+ if e.ComplexityRoot.Database.Tables == nil {
+ break
+ }
+
+ args, err := ec.field_Database_tables_args(ctx, rawArgs)
+ if err != nil {
+ return 0, false
+ }
+
+ return e.ComplexityRoot.Database.Tables(childComplexity, args["ref"].(*string)), true
+ case "Database.updated":
+ if e.ComplexityRoot.Database.Updated == nil {
+ break
+ }
+
+ return e.ComplexityRoot.Database.Updated(childComplexity), true
+ case "Database.visibility":
+ if e.ComplexityRoot.Database.Visibility == nil {
+ break
+ }
+
+ return e.ComplexityRoot.Database.Visibility(childComplexity), true
+
+ case "DatabaseCursor.cursor":
+ if e.ComplexityRoot.DatabaseCursor.Cursor == nil {
+ break
+ }
+
+ return e.ComplexityRoot.DatabaseCursor.Cursor(childComplexity), true
+ case "DatabaseCursor.results":
+ if e.ComplexityRoot.DatabaseCursor.Results == nil {
+ break
+ }
+
+ return e.ComplexityRoot.DatabaseCursor.Results(childComplexity), true
+
+ case "Query.database":
+ if e.ComplexityRoot.Query.Database == nil {
+ break
+ }
+
+ args, err := ec.field_Query_database_args(ctx, rawArgs)
+ if err != nil {
+ return 0, false
+ }
+
+ return e.ComplexityRoot.Query.Database(childComplexity, args["owner"].(string), args["name"].(string)), true
+ case "Query.databases":
+ if e.ComplexityRoot.Query.Databases == nil {
+ break
+ }
+
+ args, err := ec.field_Query_databases_args(ctx, rawArgs)
+ if err != nil {
+ return 0, false
+ }
+
+ return e.ComplexityRoot.Query.Databases(childComplexity, args["cursor"].(*model.Cursor), args["filter"].(*model.Filter)), true
+ case "Query.databasesByOwner":
+ if e.ComplexityRoot.Query.DatabasesByOwner == nil {
+ break
+ }
+
+ args, err := ec.field_Query_databasesByOwner_args(ctx, rawArgs)
+ if err != nil {
+ return 0, false
+ }
+
+ return e.ComplexityRoot.Query.DatabasesByOwner(childComplexity, args["owner"].(string), args["cursor"].(*model.Cursor), args["filter"].(*model.Filter)), true
+
+ case "Query.me":
+ if e.ComplexityRoot.Query.Me == nil {
+ break
+ }
+
+ return e.ComplexityRoot.Query.Me(childComplexity), true
+
+ case "Table.columns":
+ if e.ComplexityRoot.Table.Columns == nil {
+ break
+ }
+
+ return e.ComplexityRoot.Table.Columns(childComplexity), true
+ case "Table.name":
+ if e.ComplexityRoot.Table.Name == nil {
+ break
+ }
+
+ return e.ComplexityRoot.Table.Name(childComplexity), true
+ case "Table.rowCount":
+ if e.ComplexityRoot.Table.RowCount == nil {
+ break
+ }
+
+ return e.ComplexityRoot.Table.RowCount(childComplexity), true
+
+ case "User.canonicalName":
+ if e.ComplexityRoot.User.CanonicalName == nil {
+ break
+ }
+
+ return e.ComplexityRoot.User.CanonicalName(childComplexity), true
+ case "User.username":
+ if e.ComplexityRoot.User.Username == nil {
+ break
+ }
+
+ return e.ComplexityRoot.User.Username(childComplexity), true
+
+ }
+ return 0, false
+}
+
+func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler {
+ opCtx := graphql.GetOperationContext(ctx)
+ ec := newExecutionContext(opCtx, e, make(chan graphql.DeferredResult))
+ inputUnmarshalMap := graphql.BuildUnmarshalerMap(
+ ec.unmarshalInputFilter,
+ )
+ first := true
+
+ switch opCtx.Operation.Operation {
+ case ast.Query:
+ return func(ctx context.Context) *graphql.Response {
+ var response graphql.Response
+ var data graphql.Marshaler
+ if first {
+ first = false
+ ctx = graphql.WithUnmarshalerMap(ctx, inputUnmarshalMap)
+ data = ec._Query(ctx, opCtx.Operation.SelectionSet)
+ } else {
+ if atomic.LoadInt32(&ec.PendingDeferred) > 0 {
+ result := <-ec.DeferredResults
+ atomic.AddInt32(&ec.PendingDeferred, -1)
+ data = result.Result
+ response.Path = result.Path
+ response.Label = result.Label
+ response.Errors = result.Errors
+ } else {
+ return nil
+ }
+ }
+ var buf bytes.Buffer
+ data.MarshalGQL(&buf)
+ response.Data = buf.Bytes()
+ if atomic.LoadInt32(&ec.Deferred) > 0 {
+ hasNext := atomic.LoadInt32(&ec.PendingDeferred) > 0
+ response.HasNext = &hasNext
+ }
+
+ return &response
+ }
+
+ default:
+ return graphql.OneShot(graphql.ErrorResponse(ctx, "unsupported GraphQL operation"))
+ }
+}
+
+type executionContext struct {
+ *graphql.ExecutionContextState[ResolverRoot, DirectiveRoot, ComplexityRoot]
+}
+
+func newExecutionContext(
+ opCtx *graphql.OperationContext,
+ execSchema *executableSchema,
+ deferredResults chan graphql.DeferredResult,
+) *executionContext {
+ return &executionContext{
+ ExecutionContextState: graphql.NewExecutionContextState[ResolverRoot, DirectiveRoot, ComplexityRoot](
+ opCtx,
+ (*graphql.ExecutableSchemaState[ResolverRoot, DirectiveRoot, ComplexityRoot])(execSchema),
+ parsedSchema,
+ deferredResults,
+ ),
+ }
+}
+
+var sources = []*ast.Source{
+ {Name: "../schema.graphqls", Input: `# dolt.sr.ht — the read schema.
+#
+# There are no mutations here, and the reason is the same one spec.sr.ht gives:
+# a type federated into api.sr.ht is a consumed contract, expensive to churn, so
+# only what has settled is published. Creating, renaming and deleting a database
+# each move a metadata row and an on-disk store together, and that pairing is
+# young; it stays behind the web UI until it is not.
+#
+# Rows and diffs are absent for a different reason. They exist on /mcp, where a
+# read that had to be clipped says so in its own answer — a shape this schema
+# would have to reproduce field by field to stay honest. Until it does, a client
+# that wants table contents should ask /mcp, and this schema stops at the
+# structure: what databases exist, what branches and commits they carry, and
+# what tables live at a ref.
+#
+# Everything below is read through the same db/ store and browse/ session the
+# web pages and the MCP tools use, so the three surfaces cannot disagree about
+# what a database is.
+
+"""
+An RFC-3339 timestamp.
+"""
+scalar Time
+
+"""
+An opaque pagination cursor. Pass it back into the same field to fetch the next
+page; it is null when there are no further results.
+"""
+scalar Cursor
+
+"""
+Who may see a database, and how it is listed.
+
+PUBLIC is listed to everyone including anonymous callers. UNLISTED is reachable
+by direct address but never appears in a listing to a stranger. PRIVATE is
+neither: to a caller who may not see it, it does not exist — this schema answers
+null rather than an authorization error, exactly as the web UI answers "no such
+database" rather than "forbidden".
+"""
+enum Visibility {
+ PUBLIC
+ UNLISTED
+ PRIVATE
+}
+
+"""
+An ACL grant: read-only (browse and clone) or read-write (and push).
+"""
+enum AccessMode {
+ RO
+ RW
+}
+
+"""
+A SourceHut account, mirrored from meta.sr.ht.
+"""
+type User {
+ """
+ The username with no leading "~". This is the name that addresses the account
+ in ` + "`" + `database(owner:)` + "`" + ` and in a clone URL's path.
+ """
+ username: String!
+
+ """
+ The username with its leading "~", as SourceHut writes it in prose and in the
+ web UI.
+ """
+ canonicalName: String!
+}
+
+"""
+A hosted Dolt database: one metadata row and one bare chunk store.
+"""
+type Database {
+ id: Int!
+ name: String!
+ owner: User!
+
+ """
+ The description shown in listings. Empty rather than null when unset: a
+ companion of a git repository mirrors that repository's description, and "no
+ description" and "the empty description" are the same state here.
+ """
+ description: String!
+ visibility: Visibility!
+ created: Time!
+ updated: Time!
+
+ """
+ The branch a reader lands on: "main" when it exists, else the first branch by
+ name. Null for a database nothing has been pushed to yet — a store with no
+ commits has no branches, which is a state and not a failure.
+ """
+ defaultBranch: String
+
+ """
+ Every branch, the default one first and the rest by name. Empty for a database
+ nothing has been pushed to.
+ """
+ branches: [Branch!]!
+
+ """
+ The commit log of ` + "`" + `ref` + "`" + `, newest first. ` + "`" + `ref` + "`" + ` is a branch name or a commit
+ hash, defaulting to ` + "`" + `defaultBranch` + "`" + `; ` + "`" + `from` + "`" + ` continues a previous page from the
+ hash it returned as ` + "`" + `cursor` + "`" + `.
+ """
+ log(ref: String, from: Cursor, limit: Int): CommitCursor!
+
+ """
+ The tables of the committed root at ` + "`" + `ref` + "`" + ` (a branch name or a commit hash,
+ defaulting to ` + "`" + `defaultBranch` + "`" + `), each with its columns and row count.
+ """
+ tables(ref: String): [Table!]!
+
+ """
+ Who else may read or write this database. Owner-only: to anybody else it is
+ the empty list, because the collaborator list of a database you do not own is
+ not yours to enumerate.
+ """
+ acl: [ACLEntry!]!
+}
+
+"""
+A branch and the commit it points at.
+"""
+type Branch {
+ name: String!
+ head: String!
+}
+
+"""
+One commit of a database's history.
+"""
+type Commit {
+ hash: String!
+ author: String!
+ email: String!
+ date: Time!
+ message: String!
+ parents: [String!]!
+}
+
+"""
+A column of a table, as the stored schema declares it.
+"""
+type Column {
+ name: String!
+ type: String!
+ primaryKey: Boolean!
+ nullable: Boolean!
+}
+
+"""
+A table at a ref: its schema and how many rows it holds there.
+"""
+type Table {
+ name: String!
+ columns: [Column!]!
+ rowCount: Int!
+}
+
+"""
+An access grant on a database.
+"""
+type ACLEntry {
+ user: User!
+ mode: AccessMode!
+}
+
+"""
+How a listing is paged. It is git.sr.ht's ` + "`" + `Filter` + "`" + ` minus ` + "`" + `search` + "`" + `: nothing here
+searches yet, and declaring a field this schema would ignore is a worse answer
+than not declaring it.
+"""
+input Filter {
+ """
+ How many results one page holds, capped at 100. It travels in the cursor the
+ page returns, so it is given once and kept for the rest of the walk.
+ """
+ count: Int = 25
+}
+
+type DatabaseCursor {
+ results: [Database!]!
+ cursor: Cursor
+}
+
+type CommitCursor {
+ results: [Commit!]!
+ cursor: Cursor
+}
+
+type Query {
+ """
+ The caller, or null for an anonymous one. Anonymous is a normal caller on this
+ schema — it reads what an anonymous visitor reads — so a null here is an
+ answer and not an error.
+ """
+ me: User
+
+ """
+ Every database the caller may be shown, newest first, across all owners.
+
+ This is the listing rule and not the read rule: PUBLIC to everyone, plus
+ whatever the caller owns or holds an ACL entry on. An UNLISTED database of
+ somebody else is absent here and still readable through ` + "`" + `database` + "`" + `.
+ """
+ databases(cursor: Cursor, filter: Filter): DatabaseCursor!
+
+ """
+ One owner's databases, under the same listing rule as ` + "`" + `databases` + "`" + `. ` + "`" + `owner` + "`" + `
+ carries no leading "~".
+ """
+ databasesByOwner(owner: String!, cursor: Cursor, filter: Filter): DatabaseCursor!
+
+ """
+ One database by owner and name, neither carrying a leading "~". Null when
+ there is no such database *or* when the caller may not see it — the two are
+ deliberately one answer, so that a PRIVATE database cannot be discovered by
+ the shape of the refusal.
+ """
+ database(owner: String!, name: String!): Database
+}
+`, BuiltIn: false},
+}
+var parsedSchema = gqlparser.MustLoadSchema(sources...)
+
+// childFields_* functions provide shared child field context lookups.
+// Each function is generated once per unique object type, deduplicating the
+// switch statements that were previously inlined in every fieldContext_* function.
+
+func (ec *executionContext) childFields_ACLEntry(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ switch field.Name {
+ case "user":
+ return ec.fieldContext_ACLEntry_user(ctx, field)
+ case "mode":
+ return ec.fieldContext_ACLEntry_mode(ctx, field)
+ }
+ return nil, fmt.Errorf("no field named %q was found under type ACLEntry", field.Name)
+}
+
+func (ec *executionContext) childFields_Branch(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ switch field.Name {
+ case "name":
+ return ec.fieldContext_Branch_name(ctx, field)
+ case "head":
+ return ec.fieldContext_Branch_head(ctx, field)
+ }
+ return nil, fmt.Errorf("no field named %q was found under type Branch", field.Name)
+}
+
+func (ec *executionContext) childFields_Column(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ switch field.Name {
+ case "name":
+ return ec.fieldContext_Column_name(ctx, field)
+ case "type":
+ return ec.fieldContext_Column_type(ctx, field)
+ case "primaryKey":
+ return ec.fieldContext_Column_primaryKey(ctx, field)
+ case "nullable":
+ return ec.fieldContext_Column_nullable(ctx, field)
+ }
+ return nil, fmt.Errorf("no field named %q was found under type Column", field.Name)
+}
+
+func (ec *executionContext) childFields_Commit(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ switch field.Name {
+ case "hash":
+ return ec.fieldContext_Commit_hash(ctx, field)
+ case "author":
+ return ec.fieldContext_Commit_author(ctx, field)
+ case "email":
+ return ec.fieldContext_Commit_email(ctx, field)
+ case "date":
+ return ec.fieldContext_Commit_date(ctx, field)
+ case "message":
+ return ec.fieldContext_Commit_message(ctx, field)
+ case "parents":
+ return ec.fieldContext_Commit_parents(ctx, field)
+ }
+ return nil, fmt.Errorf("no field named %q was found under type Commit", field.Name)
+}
+
+func (ec *executionContext) childFields_CommitCursor(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ switch field.Name {
+ case "results":
+ return ec.fieldContext_CommitCursor_results(ctx, field)
+ case "cursor":
+ return ec.fieldContext_CommitCursor_cursor(ctx, field)
+ }
+ return nil, fmt.Errorf("no field named %q was found under type CommitCursor", field.Name)
+}
+
+func (ec *executionContext) childFields_Database(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ switch field.Name {
+ case "id":
+ return ec.fieldContext_Database_id(ctx, field)
+ case "name":
+ return ec.fieldContext_Database_name(ctx, field)
+ case "owner":
+ return ec.fieldContext_Database_owner(ctx, field)
+ case "description":
+ return ec.fieldContext_Database_description(ctx, field)
+ case "visibility":
+ return ec.fieldContext_Database_visibility(ctx, field)
+ case "created":
+ return ec.fieldContext_Database_created(ctx, field)
+ case "updated":
+ return ec.fieldContext_Database_updated(ctx, field)
+ case "defaultBranch":
+ return ec.fieldContext_Database_defaultBranch(ctx, field)
+ case "branches":
+ return ec.fieldContext_Database_branches(ctx, field)
+ case "log":
+ return ec.fieldContext_Database_log(ctx, field)
+ case "tables":
+ return ec.fieldContext_Database_tables(ctx, field)
+ case "acl":
+ return ec.fieldContext_Database_acl(ctx, field)
+ }
+ return nil, fmt.Errorf("no field named %q was found under type Database", field.Name)
+}
+
+func (ec *executionContext) childFields_DatabaseCursor(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ switch field.Name {
+ case "results":
+ return ec.fieldContext_DatabaseCursor_results(ctx, field)
+ case "cursor":
+ return ec.fieldContext_DatabaseCursor_cursor(ctx, field)
+ }
+ return nil, fmt.Errorf("no field named %q was found under type DatabaseCursor", field.Name)
+}
+
+func (ec *executionContext) childFields_Table(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ switch field.Name {
+ case "name":
+ return ec.fieldContext_Table_name(ctx, field)
+ case "columns":
+ return ec.fieldContext_Table_columns(ctx, field)
+ case "rowCount":
+ return ec.fieldContext_Table_rowCount(ctx, field)
+ }
+ return nil, fmt.Errorf("no field named %q was found under type Table", field.Name)
+}
+
+func (ec *executionContext) childFields_User(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ switch field.Name {
+ case "username":
+ return ec.fieldContext_User_username(ctx, field)
+ case "canonicalName":
+ return ec.fieldContext_User_canonicalName(ctx, field)
+ }
+ return nil, fmt.Errorf("no field named %q was found under type User", field.Name)
+}
+
+func (ec *executionContext) childFields___Directive(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ switch field.Name {
+ case "name":
+ return ec.fieldContext___Directive_name(ctx, field)
+ case "description":
+ return ec.fieldContext___Directive_description(ctx, field)
+ case "isRepeatable":
+ return ec.fieldContext___Directive_isRepeatable(ctx, field)
+ case "locations":
+ return ec.fieldContext___Directive_locations(ctx, field)
+ case "args":
+ return ec.fieldContext___Directive_args(ctx, field)
+ }
+ return nil, fmt.Errorf("no field named %q was found under type __Directive", field.Name)
+}
+
+func (ec *executionContext) childFields___EnumValue(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ switch field.Name {
+ case "name":
+ return ec.fieldContext___EnumValue_name(ctx, field)
+ case "description":
+ return ec.fieldContext___EnumValue_description(ctx, field)
+ case "isDeprecated":
+ return ec.fieldContext___EnumValue_isDeprecated(ctx, field)
+ case "deprecationReason":
+ return ec.fieldContext___EnumValue_deprecationReason(ctx, field)
+ }
+ return nil, fmt.Errorf("no field named %q was found under type __EnumValue", field.Name)
+}
+
+func (ec *executionContext) childFields___Field(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ switch field.Name {
+ case "name":
+ return ec.fieldContext___Field_name(ctx, field)
+ case "description":
+ return ec.fieldContext___Field_description(ctx, field)
+ case "args":
+ return ec.fieldContext___Field_args(ctx, field)
+ case "type":
+ return ec.fieldContext___Field_type(ctx, field)
+ case "isDeprecated":
+ return ec.fieldContext___Field_isDeprecated(ctx, field)
+ case "deprecationReason":
+ return ec.fieldContext___Field_deprecationReason(ctx, field)
+ }
+ return nil, fmt.Errorf("no field named %q was found under type __Field", field.Name)
+}
+
+func (ec *executionContext) childFields___InputValue(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ switch field.Name {
+ case "name":
+ return ec.fieldContext___InputValue_name(ctx, field)
+ case "description":
+ return ec.fieldContext___InputValue_description(ctx, field)
+ case "type":
+ return ec.fieldContext___InputValue_type(ctx, field)
+ case "defaultValue":
+ return ec.fieldContext___InputValue_defaultValue(ctx, field)
+ case "isDeprecated":
+ return ec.fieldContext___InputValue_isDeprecated(ctx, field)
+ case "deprecationReason":
+ return ec.fieldContext___InputValue_deprecationReason(ctx, field)
+ }
+ return nil, fmt.Errorf("no field named %q was found under type __InputValue", field.Name)
+}
+
+func (ec *executionContext) childFields___Schema(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ switch field.Name {
+ case "description":
+ return ec.fieldContext___Schema_description(ctx, field)
+ case "types":
+ return ec.fieldContext___Schema_types(ctx, field)
+ case "queryType":
+ return ec.fieldContext___Schema_queryType(ctx, field)
+ case "mutationType":
+ return ec.fieldContext___Schema_mutationType(ctx, field)
+ case "subscriptionType":
+ return ec.fieldContext___Schema_subscriptionType(ctx, field)
+ case "directives":
+ return ec.fieldContext___Schema_directives(ctx, field)
+ }
+ return nil, fmt.Errorf("no field named %q was found under type __Schema", field.Name)
+}
+
+func (ec *executionContext) childFields___Type(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ switch field.Name {
+ case "kind":
+ return ec.fieldContext___Type_kind(ctx, field)
+ case "name":
+ return ec.fieldContext___Type_name(ctx, field)
+ case "description":
+ return ec.fieldContext___Type_description(ctx, field)
+ case "specifiedByURL":
+ return ec.fieldContext___Type_specifiedByURL(ctx, field)
+ case "fields":
+ return ec.fieldContext___Type_fields(ctx, field)
+ case "interfaces":
+ return ec.fieldContext___Type_interfaces(ctx, field)
+ case "possibleTypes":
+ return ec.fieldContext___Type_possibleTypes(ctx, field)
+ case "enumValues":
+ return ec.fieldContext___Type_enumValues(ctx, field)
+ case "inputFields":
+ return ec.fieldContext___Type_inputFields(ctx, field)
+ case "ofType":
+ return ec.fieldContext___Type_ofType(ctx, field)
+ case "isOneOf":
+ return ec.fieldContext___Type_isOneOf(ctx, field)
+ }
+ return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
+}
+
+// endregion ************************** internal!.gotpl ***************************
+
+// region ***************************** args.gotpl *****************************
+
+func (ec *executionContext) field_Database_log_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
+ var err error
+ args := map[string]any{}
+ arg0, err := graphql.ProcessArgField(ctx, rawArgs, "ref",
+ func(ctx context.Context, v any) (*string, error) {
+ return ec.unmarshalOString2ᚖstring(ctx, v)
+ })
+ if err != nil {
+ return nil, err
+ }
+ args["ref"] = arg0
+ arg1, err := graphql.ProcessArgField(ctx, rawArgs, "from",
+ func(ctx context.Context, v any) (*model.Cursor, error) {
+ return ec.unmarshalOCursor2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑcoreᚋmodelᚐCursor(ctx, v)
+ })
+ if err != nil {
+ return nil, err
+ }
+ args["from"] = arg1
+ arg2, err := graphql.ProcessArgField(ctx, rawArgs, "limit",
+ func(ctx context.Context, v any) (*int, error) {
+ return ec.unmarshalOInt2ᚖint(ctx, v)
+ })
+ if err != nil {
+ return nil, err
+ }
+ args["limit"] = arg2
+ return args, nil
+}
+
+func (ec *executionContext) field_Database_tables_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
+ var err error
+ args := map[string]any{}
+ arg0, err := graphql.ProcessArgField(ctx, rawArgs, "ref",
+ func(ctx context.Context, v any) (*string, error) {
+ return ec.unmarshalOString2ᚖstring(ctx, v)
+ })
+ if err != nil {
+ return nil, err
+ }
+ args["ref"] = arg0
+ return args, nil
+}
+
+func (ec *executionContext) field_Query___type_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
+ var err error
+ args := map[string]any{}
+ arg0, err := graphql.ProcessArgField(ctx, rawArgs, "name",
+ func(ctx context.Context, v any) (string, error) {
+ return ec.unmarshalNString2string(ctx, v)
+ })
+ if err != nil {
+ return nil, err
+ }
+ args["name"] = arg0
+ return args, nil
+}
+
+func (ec *executionContext) field_Query_database_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
+ var err error
+ args := map[string]any{}
+ arg0, err := graphql.ProcessArgField(ctx, rawArgs, "owner",
+ func(ctx context.Context, v any) (string, error) {
+ return ec.unmarshalNString2string(ctx, v)
+ })
+ if err != nil {
+ return nil, err
+ }
+ args["owner"] = arg0
+ arg1, err := graphql.ProcessArgField(ctx, rawArgs, "name",
+ func(ctx context.Context, v any) (string, error) {
+ return ec.unmarshalNString2string(ctx, v)
+ })
+ if err != nil {
+ return nil, err
+ }
+ args["name"] = arg1
+ return args, nil
+}
+
+func (ec *executionContext) field_Query_databasesByOwner_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
+ var err error
+ args := map[string]any{}
+ arg0, err := graphql.ProcessArgField(ctx, rawArgs, "owner",
+ func(ctx context.Context, v any) (string, error) {
+ return ec.unmarshalNString2string(ctx, v)
+ })
+ if err != nil {
+ return nil, err
+ }
+ args["owner"] = arg0
+ arg1, err := graphql.ProcessArgField(ctx, rawArgs, "cursor",
+ func(ctx context.Context, v any) (*model.Cursor, error) {
+ return ec.unmarshalOCursor2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑcoreᚋmodelᚐCursor(ctx, v)
+ })
+ if err != nil {
+ return nil, err
+ }
+ args["cursor"] = arg1
+ arg2, err := graphql.ProcessArgField(ctx, rawArgs, "filter",
+ func(ctx context.Context, v any) (*model.Filter, error) {
+ return ec.unmarshalOFilter2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑcoreᚋmodelᚐFilter(ctx, v)
+ })
+ if err != nil {
+ return nil, err
+ }
+ args["filter"] = arg2
+ return args, nil
+}
+
+func (ec *executionContext) field_Query_databases_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
+ var err error
+ args := map[string]any{}
+ arg0, err := graphql.ProcessArgField(ctx, rawArgs, "cursor",
+ func(ctx context.Context, v any) (*model.Cursor, error) {
+ return ec.unmarshalOCursor2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑcoreᚋmodelᚐCursor(ctx, v)
+ })
+ if err != nil {
+ return nil, err
+ }
+ args["cursor"] = arg0
+ arg1, err := graphql.ProcessArgField(ctx, rawArgs, "filter",
+ func(ctx context.Context, v any) (*model.Filter, error) {
+ return ec.unmarshalOFilter2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑcoreᚋmodelᚐFilter(ctx, v)
+ })
+ if err != nil {
+ return nil, err
+ }
+ args["filter"] = arg1
+ return args, nil
+}
+
+func (ec *executionContext) field___Directive_args_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
+ var err error
+ args := map[string]any{}
+ arg0, err := graphql.ProcessArgField(ctx, rawArgs, "includeDeprecated",
+ func(ctx context.Context, v any) (*bool, error) {
+ return ec.unmarshalOBoolean2ᚖbool(ctx, v)
+ })
+ if err != nil {
+ return nil, err
+ }
+ args["includeDeprecated"] = arg0
+ return args, nil
+}
+
+func (ec *executionContext) field___Field_args_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
+ var err error
+ args := map[string]any{}
+ arg0, err := graphql.ProcessArgField(ctx, rawArgs, "includeDeprecated",
+ func(ctx context.Context, v any) (*bool, error) {
+ return ec.unmarshalOBoolean2ᚖbool(ctx, v)
+ })
+ if err != nil {
+ return nil, err
+ }
+ args["includeDeprecated"] = arg0
+ return args, nil
+}
+
+func (ec *executionContext) field___Type_enumValues_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
+ var err error
+ args := map[string]any{}
+ arg0, err := graphql.ProcessArgField(ctx, rawArgs, "includeDeprecated",
+ func(ctx context.Context, v any) (bool, error) {
+ return ec.unmarshalOBoolean2bool(ctx, v)
+ })
+ if err != nil {
+ return nil, err
+ }
+ args["includeDeprecated"] = arg0
+ return args, nil
+}
+
+func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
+ var err error
+ args := map[string]any{}
+ arg0, err := graphql.ProcessArgField(ctx, rawArgs, "includeDeprecated",
+ func(ctx context.Context, v any) (bool, error) {
+ return ec.unmarshalOBoolean2bool(ctx, v)
+ })
+ if err != nil {
+ return nil, err
+ }
+ args["includeDeprecated"] = arg0
+ return args, nil
+}
+
+// endregion ***************************** args.gotpl *****************************
+
+// region **************************** field.gotpl *****************************
+
+func (ec *executionContext) _ACLEntry_user(ctx context.Context, field graphql.CollectedField, obj *model1.ACLEntry) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext_ACLEntry_user(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.User, nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v *model1.User) graphql.Marshaler {
+ return ec.marshalNUser2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐUser(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext_ACLEntry_user(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "ACLEntry",
+ Field: field,
+ IsMethod: false,
+ IsResolver: false,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.childFields_User(ctx, field)
+ },
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) _ACLEntry_mode(ctx context.Context, field graphql.CollectedField, obj *model1.ACLEntry) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext_ACLEntry_mode(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Mode, nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v model1.AccessMode) graphql.Marshaler {
+ return ec.marshalNAccessMode2sourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐAccessMode(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext_ACLEntry_mode(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("ACLEntry", field, false, false, errors.New("field of type AccessMode does not have child fields"))
+}
+
+func (ec *executionContext) _Branch_name(ctx context.Context, field graphql.CollectedField, obj *model1.Branch) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext_Branch_name(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Name, nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
+ return ec.marshalNString2string(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext_Branch_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("Branch", field, false, false, errors.New("field of type String does not have child fields"))
+}
+
+func (ec *executionContext) _Branch_head(ctx context.Context, field graphql.CollectedField, obj *model1.Branch) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext_Branch_head(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Head, nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
+ return ec.marshalNString2string(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext_Branch_head(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("Branch", field, false, false, errors.New("field of type String does not have child fields"))
+}
+
+func (ec *executionContext) _Column_name(ctx context.Context, field graphql.CollectedField, obj *model1.Column) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext_Column_name(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Name, nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
+ return ec.marshalNString2string(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext_Column_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("Column", field, false, false, errors.New("field of type String does not have child fields"))
+}
+
+func (ec *executionContext) _Column_type(ctx context.Context, field graphql.CollectedField, obj *model1.Column) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext_Column_type(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Type, nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
+ return ec.marshalNString2string(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext_Column_type(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("Column", field, false, false, errors.New("field of type String does not have child fields"))
+}
+
+func (ec *executionContext) _Column_primaryKey(ctx context.Context, field graphql.CollectedField, obj *model1.Column) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext_Column_primaryKey(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.PrimaryKey, nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v bool) graphql.Marshaler {
+ return ec.marshalNBoolean2bool(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext_Column_primaryKey(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("Column", field, false, false, errors.New("field of type Boolean does not have child fields"))
+}
+
+func (ec *executionContext) _Column_nullable(ctx context.Context, field graphql.CollectedField, obj *model1.Column) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext_Column_nullable(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Nullable, nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v bool) graphql.Marshaler {
+ return ec.marshalNBoolean2bool(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext_Column_nullable(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("Column", field, false, false, errors.New("field of type Boolean does not have child fields"))
+}
+
+func (ec *executionContext) _Commit_hash(ctx context.Context, field graphql.CollectedField, obj *model1.Commit) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext_Commit_hash(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Hash, nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
+ return ec.marshalNString2string(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext_Commit_hash(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("Commit", field, false, false, errors.New("field of type String does not have child fields"))
+}
+
+func (ec *executionContext) _Commit_author(ctx context.Context, field graphql.CollectedField, obj *model1.Commit) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext_Commit_author(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Author, nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
+ return ec.marshalNString2string(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext_Commit_author(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("Commit", field, false, false, errors.New("field of type String does not have child fields"))
+}
+
+func (ec *executionContext) _Commit_email(ctx context.Context, field graphql.CollectedField, obj *model1.Commit) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext_Commit_email(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Email, nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
+ return ec.marshalNString2string(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext_Commit_email(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("Commit", field, false, false, errors.New("field of type String does not have child fields"))
+}
+
+func (ec *executionContext) _Commit_date(ctx context.Context, field graphql.CollectedField, obj *model1.Commit) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext_Commit_date(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Date, nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v time.Time) graphql.Marshaler {
+ return ec.marshalNTime2timeᚐTime(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext_Commit_date(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("Commit", field, false, false, errors.New("field of type Time does not have child fields"))
+}
+
+func (ec *executionContext) _Commit_message(ctx context.Context, field graphql.CollectedField, obj *model1.Commit) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext_Commit_message(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Message, nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
+ return ec.marshalNString2string(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext_Commit_message(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("Commit", field, false, false, errors.New("field of type String does not have child fields"))
+}
+
+func (ec *executionContext) _Commit_parents(ctx context.Context, field graphql.CollectedField, obj *model1.Commit) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext_Commit_parents(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Parents, nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v []string) graphql.Marshaler {
+ return ec.marshalNString2ᚕstringᚄ(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext_Commit_parents(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("Commit", field, false, false, errors.New("field of type String does not have child fields"))
+}
+
+func (ec *executionContext) _CommitCursor_results(ctx context.Context, field graphql.CollectedField, obj *model1.CommitCursor) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext_CommitCursor_results(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Results, nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v []*model1.Commit) graphql.Marshaler {
+ return ec.marshalNCommit2ᚕᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐCommitᚄ(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext_CommitCursor_results(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "CommitCursor",
+ Field: field,
+ IsMethod: false,
+ IsResolver: false,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.childFields_Commit(ctx, field)
+ },
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) _CommitCursor_cursor(ctx context.Context, field graphql.CollectedField, obj *model1.CommitCursor) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext_CommitCursor_cursor(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Cursor, nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v *model.Cursor) graphql.Marshaler {
+ return ec.marshalOCursor2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑcoreᚋmodelᚐCursor(ctx, selections, v)
+ },
+ true,
+ false,
+ )
+}
+func (ec *executionContext) fieldContext_CommitCursor_cursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("CommitCursor", field, false, false, errors.New("field of type Cursor does not have child fields"))
+}
+
+func (ec *executionContext) _Database_id(ctx context.Context, field graphql.CollectedField, obj *model1.Database) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext_Database_id(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.ID, nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v int) graphql.Marshaler {
+ return ec.marshalNInt2int(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext_Database_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("Database", field, false, false, errors.New("field of type Int does not have child fields"))
+}
+
+func (ec *executionContext) _Database_name(ctx context.Context, field graphql.CollectedField, obj *model1.Database) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext_Database_name(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Name, nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
+ return ec.marshalNString2string(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext_Database_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("Database", field, false, false, errors.New("field of type String does not have child fields"))
+}
+
+func (ec *executionContext) _Database_owner(ctx context.Context, field graphql.CollectedField, obj *model1.Database) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext_Database_owner(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Owner, nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v *model1.User) graphql.Marshaler {
+ return ec.marshalNUser2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐUser(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext_Database_owner(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "Database",
+ Field: field,
+ IsMethod: false,
+ IsResolver: false,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.childFields_User(ctx, field)
+ },
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) _Database_description(ctx context.Context, field graphql.CollectedField, obj *model1.Database) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext_Database_description(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Description, nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
+ return ec.marshalNString2string(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext_Database_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("Database", field, false, false, errors.New("field of type String does not have child fields"))
+}
+
+func (ec *executionContext) _Database_visibility(ctx context.Context, field graphql.CollectedField, obj *model1.Database) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext_Database_visibility(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Visibility, nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v model1.Visibility) graphql.Marshaler {
+ return ec.marshalNVisibility2sourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐVisibility(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext_Database_visibility(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("Database", field, false, false, errors.New("field of type Visibility does not have child fields"))
+}
+
+func (ec *executionContext) _Database_created(ctx context.Context, field graphql.CollectedField, obj *model1.Database) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext_Database_created(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Created, nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v time.Time) graphql.Marshaler {
+ return ec.marshalNTime2timeᚐTime(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext_Database_created(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("Database", field, false, false, errors.New("field of type Time does not have child fields"))
+}
+
+func (ec *executionContext) _Database_updated(ctx context.Context, field graphql.CollectedField, obj *model1.Database) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext_Database_updated(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Updated, nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v time.Time) graphql.Marshaler {
+ return ec.marshalNTime2timeᚐTime(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext_Database_updated(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("Database", field, false, false, errors.New("field of type Time does not have child fields"))
+}
+
+func (ec *executionContext) _Database_defaultBranch(ctx context.Context, field graphql.CollectedField, obj *model1.Database) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext_Database_defaultBranch(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return ec.Resolvers.Database().DefaultBranch(ctx, obj)
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v *string) graphql.Marshaler {
+ return ec.marshalOString2ᚖstring(ctx, selections, v)
+ },
+ true,
+ false,
+ )
+}
+func (ec *executionContext) fieldContext_Database_defaultBranch(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("Database", field, true, true, errors.New("field of type String does not have child fields"))
+}
+
+func (ec *executionContext) _Database_branches(ctx context.Context, field graphql.CollectedField, obj *model1.Database) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext_Database_branches(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return ec.Resolvers.Database().Branches(ctx, obj)
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v []*model1.Branch) graphql.Marshaler {
+ return ec.marshalNBranch2ᚕᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐBranchᚄ(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext_Database_branches(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "Database",
+ Field: field,
+ IsMethod: true,
+ IsResolver: true,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.childFields_Branch(ctx, field)
+ },
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) _Database_log(ctx context.Context, field graphql.CollectedField, obj *model1.Database) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext_Database_log(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ fc := graphql.GetFieldContext(ctx)
+ return ec.Resolvers.Database().Log(ctx, obj, fc.Args["ref"].(*string), fc.Args["from"].(*model.Cursor), fc.Args["limit"].(*int))
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v *model1.CommitCursor) graphql.Marshaler {
+ return ec.marshalNCommitCursor2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐCommitCursor(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext_Database_log(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "Database",
+ Field: field,
+ IsMethod: true,
+ IsResolver: true,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.childFields_CommitCursor(ctx, field)
+ },
+ }
+ defer func() {
+ if r := recover(); r != nil {
+ err = ec.Recover(ctx, r)
+ ec.Error(ctx, err)
+ }
+ }()
+ ctx = graphql.WithFieldContext(ctx, fc)
+ if fc.Args, err = ec.field_Database_log_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
+ ec.Error(ctx, err)
+ return fc, err
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) _Database_tables(ctx context.Context, field graphql.CollectedField, obj *model1.Database) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext_Database_tables(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ fc := graphql.GetFieldContext(ctx)
+ return ec.Resolvers.Database().Tables(ctx, obj, fc.Args["ref"].(*string))
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v []*model1.Table) graphql.Marshaler {
+ return ec.marshalNTable2ᚕᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐTableᚄ(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext_Database_tables(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "Database",
+ Field: field,
+ IsMethod: true,
+ IsResolver: true,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.childFields_Table(ctx, field)
+ },
+ }
+ defer func() {
+ if r := recover(); r != nil {
+ err = ec.Recover(ctx, r)
+ ec.Error(ctx, err)
+ }
+ }()
+ ctx = graphql.WithFieldContext(ctx, fc)
+ if fc.Args, err = ec.field_Database_tables_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
+ ec.Error(ctx, err)
+ return fc, err
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) _Database_acl(ctx context.Context, field graphql.CollectedField, obj *model1.Database) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext_Database_acl(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return ec.Resolvers.Database().ACL(ctx, obj)
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v []*model1.ACLEntry) graphql.Marshaler {
+ return ec.marshalNACLEntry2ᚕᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐACLEntryᚄ(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext_Database_acl(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "Database",
+ Field: field,
+ IsMethod: true,
+ IsResolver: true,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.childFields_ACLEntry(ctx, field)
+ },
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) _DatabaseCursor_results(ctx context.Context, field graphql.CollectedField, obj *model1.DatabaseCursor) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext_DatabaseCursor_results(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Results, nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v []*model1.Database) graphql.Marshaler {
+ return ec.marshalNDatabase2ᚕᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐDatabaseᚄ(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext_DatabaseCursor_results(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "DatabaseCursor",
+ Field: field,
+ IsMethod: false,
+ IsResolver: false,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.childFields_Database(ctx, field)
+ },
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) _DatabaseCursor_cursor(ctx context.Context, field graphql.CollectedField, obj *model1.DatabaseCursor) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext_DatabaseCursor_cursor(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Cursor, nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v *model.Cursor) graphql.Marshaler {
+ return ec.marshalOCursor2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑcoreᚋmodelᚐCursor(ctx, selections, v)
+ },
+ true,
+ false,
+ )
+}
+func (ec *executionContext) fieldContext_DatabaseCursor_cursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("DatabaseCursor", field, false, false, errors.New("field of type Cursor does not have child fields"))
+}
+
+func (ec *executionContext) _Query_me(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext_Query_me(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return ec.Resolvers.Query().Me(ctx)
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v *model1.User) graphql.Marshaler {
+ return ec.marshalOUser2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐUser(ctx, selections, v)
+ },
+ true,
+ false,
+ )
+}
+func (ec *executionContext) fieldContext_Query_me(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "Query",
+ Field: field,
+ IsMethod: true,
+ IsResolver: true,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.childFields_User(ctx, field)
+ },
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) _Query_databases(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext_Query_databases(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ fc := graphql.GetFieldContext(ctx)
+ return ec.Resolvers.Query().Databases(ctx, fc.Args["cursor"].(*model.Cursor), fc.Args["filter"].(*model.Filter))
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v *model1.DatabaseCursor) graphql.Marshaler {
+ return ec.marshalNDatabaseCursor2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐDatabaseCursor(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext_Query_databases(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "Query",
+ Field: field,
+ IsMethod: true,
+ IsResolver: true,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.childFields_DatabaseCursor(ctx, field)
+ },
+ }
+ defer func() {
+ if r := recover(); r != nil {
+ err = ec.Recover(ctx, r)
+ ec.Error(ctx, err)
+ }
+ }()
+ ctx = graphql.WithFieldContext(ctx, fc)
+ if fc.Args, err = ec.field_Query_databases_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
+ ec.Error(ctx, err)
+ return fc, err
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) _Query_databasesByOwner(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext_Query_databasesByOwner(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ fc := graphql.GetFieldContext(ctx)
+ return ec.Resolvers.Query().DatabasesByOwner(ctx, fc.Args["owner"].(string), fc.Args["cursor"].(*model.Cursor), fc.Args["filter"].(*model.Filter))
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v *model1.DatabaseCursor) graphql.Marshaler {
+ return ec.marshalNDatabaseCursor2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐDatabaseCursor(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext_Query_databasesByOwner(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "Query",
+ Field: field,
+ IsMethod: true,
+ IsResolver: true,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.childFields_DatabaseCursor(ctx, field)
+ },
+ }
+ defer func() {
+ if r := recover(); r != nil {
+ err = ec.Recover(ctx, r)
+ ec.Error(ctx, err)
+ }
+ }()
+ ctx = graphql.WithFieldContext(ctx, fc)
+ if fc.Args, err = ec.field_Query_databasesByOwner_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
+ ec.Error(ctx, err)
+ return fc, err
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) _Query_database(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext_Query_database(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ fc := graphql.GetFieldContext(ctx)
+ return ec.Resolvers.Query().Database(ctx, fc.Args["owner"].(string), fc.Args["name"].(string))
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v *model1.Database) graphql.Marshaler {
+ return ec.marshalODatabase2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐDatabase(ctx, selections, v)
+ },
+ true,
+ false,
+ )
+}
+func (ec *executionContext) fieldContext_Query_database(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "Query",
+ Field: field,
+ IsMethod: true,
+ IsResolver: true,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.childFields_Database(ctx, field)
+ },
+ }
+ defer func() {
+ if r := recover(); r != nil {
+ err = ec.Recover(ctx, r)
+ ec.Error(ctx, err)
+ }
+ }()
+ ctx = graphql.WithFieldContext(ctx, fc)
+ if fc.Args, err = ec.field_Query_database_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
+ ec.Error(ctx, err)
+ return fc, err
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext_Query___type(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ fc := graphql.GetFieldContext(ctx)
+ return ec.IntrospectType(fc.Args["name"].(string))
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
+ return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, selections, v)
+ },
+ true,
+ false,
+ )
+}
+func (ec *executionContext) fieldContext_Query___type(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "Query",
+ Field: field,
+ IsMethod: true,
+ IsResolver: false,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.childFields___Type(ctx, field)
+ },
+ }
+ defer func() {
+ if r := recover(); r != nil {
+ err = ec.Recover(ctx, r)
+ ec.Error(ctx, err)
+ }
+ }()
+ ctx = graphql.WithFieldContext(ctx, fc)
+ if fc.Args, err = ec.field_Query___type_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
+ ec.Error(ctx, err)
+ return fc, err
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext_Query___schema(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return ec.IntrospectSchema()
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v *introspection.Schema) graphql.Marshaler {
+ return ec.marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx, selections, v)
+ },
+ true,
+ false,
+ )
+}
+func (ec *executionContext) fieldContext_Query___schema(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "Query",
+ Field: field,
+ IsMethod: true,
+ IsResolver: false,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.childFields___Schema(ctx, field)
+ },
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) _Table_name(ctx context.Context, field graphql.CollectedField, obj *model1.Table) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext_Table_name(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Name, nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
+ return ec.marshalNString2string(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext_Table_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("Table", field, false, false, errors.New("field of type String does not have child fields"))
+}
+
+func (ec *executionContext) _Table_columns(ctx context.Context, field graphql.CollectedField, obj *model1.Table) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext_Table_columns(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Columns, nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v []*model1.Column) graphql.Marshaler {
+ return ec.marshalNColumn2ᚕᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐColumnᚄ(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext_Table_columns(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "Table",
+ Field: field,
+ IsMethod: false,
+ IsResolver: false,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.childFields_Column(ctx, field)
+ },
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) _Table_rowCount(ctx context.Context, field graphql.CollectedField, obj *model1.Table) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext_Table_rowCount(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.RowCount, nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v int) graphql.Marshaler {
+ return ec.marshalNInt2int(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext_Table_rowCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("Table", field, false, false, errors.New("field of type Int does not have child fields"))
+}
+
+func (ec *executionContext) _User_username(ctx context.Context, field graphql.CollectedField, obj *model1.User) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext_User_username(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Username, nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
+ return ec.marshalNString2string(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext_User_username(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("User", field, false, false, errors.New("field of type String does not have child fields"))
+}
+
+func (ec *executionContext) _User_canonicalName(ctx context.Context, field graphql.CollectedField, obj *model1.User) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext_User_canonicalName(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.CanonicalName, nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
+ return ec.marshalNString2string(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext_User_canonicalName(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("User", field, false, false, errors.New("field of type String does not have child fields"))
+}
+
+func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext___Directive_name(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Name, nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
+ return ec.marshalNString2string(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext___Directive_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("__Directive", field, false, false, errors.New("field of type String does not have child fields"))
+}
+
+func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext___Directive_description(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Description(), nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v *string) graphql.Marshaler {
+ return ec.marshalOString2ᚖstring(ctx, selections, v)
+ },
+ true,
+ false,
+ )
+}
+func (ec *executionContext) fieldContext___Directive_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("__Directive", field, true, false, errors.New("field of type String does not have child fields"))
+}
+
+func (ec *executionContext) ___Directive_isRepeatable(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext___Directive_isRepeatable(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.IsRepeatable, nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v bool) graphql.Marshaler {
+ return ec.marshalNBoolean2bool(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext___Directive_isRepeatable(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("__Directive", field, false, false, errors.New("field of type Boolean does not have child fields"))
+}
+
+func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext___Directive_locations(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Locations, nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v []string) graphql.Marshaler {
+ return ec.marshalN__DirectiveLocation2ᚕstringᚄ(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext___Directive_locations(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("__Directive", field, false, false, errors.New("field of type __DirectiveLocation does not have child fields"))
+}
+
+func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext___Directive_args(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Args, nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
+ return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext___Directive_args(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "__Directive",
+ Field: field,
+ IsMethod: false,
+ IsResolver: false,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.childFields___InputValue(ctx, field)
+ },
+ }
+ defer func() {
+ if r := recover(); r != nil {
+ err = ec.Recover(ctx, r)
+ ec.Error(ctx, err)
+ }
+ }()
+ ctx = graphql.WithFieldContext(ctx, fc)
+ if fc.Args, err = ec.field___Directive_args_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
+ ec.Error(ctx, err)
+ return fc, err
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext___EnumValue_name(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Name, nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
+ return ec.marshalNString2string(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext___EnumValue_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("__EnumValue", field, false, false, errors.New("field of type String does not have child fields"))
+}
+
+func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext___EnumValue_description(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Description(), nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v *string) graphql.Marshaler {
+ return ec.marshalOString2ᚖstring(ctx, selections, v)
+ },
+ true,
+ false,
+ )
+}
+func (ec *executionContext) fieldContext___EnumValue_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("__EnumValue", field, true, false, errors.New("field of type String does not have child fields"))
+}
+
+func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext___EnumValue_isDeprecated(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.IsDeprecated(), nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v bool) graphql.Marshaler {
+ return ec.marshalNBoolean2bool(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext___EnumValue_isDeprecated(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("__EnumValue", field, true, false, errors.New("field of type Boolean does not have child fields"))
+}
+
+func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext___EnumValue_deprecationReason(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.DeprecationReason(), nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v *string) graphql.Marshaler {
+ return ec.marshalOString2ᚖstring(ctx, selections, v)
+ },
+ true,
+ false,
+ )
+}
+func (ec *executionContext) fieldContext___EnumValue_deprecationReason(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("__EnumValue", field, true, false, errors.New("field of type String does not have child fields"))
+}
+
+func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext___Field_name(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Name, nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
+ return ec.marshalNString2string(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext___Field_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("__Field", field, false, false, errors.New("field of type String does not have child fields"))
+}
+
+func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext___Field_description(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Description(), nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v *string) graphql.Marshaler {
+ return ec.marshalOString2ᚖstring(ctx, selections, v)
+ },
+ true,
+ false,
+ )
+}
+func (ec *executionContext) fieldContext___Field_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("__Field", field, true, false, errors.New("field of type String does not have child fields"))
+}
+
+func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext___Field_args(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Args, nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
+ return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext___Field_args(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "__Field",
+ Field: field,
+ IsMethod: false,
+ IsResolver: false,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.childFields___InputValue(ctx, field)
+ },
+ }
+ defer func() {
+ if r := recover(); r != nil {
+ err = ec.Recover(ctx, r)
+ ec.Error(ctx, err)
+ }
+ }()
+ ctx = graphql.WithFieldContext(ctx, fc)
+ if fc.Args, err = ec.field___Field_args_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
+ ec.Error(ctx, err)
+ return fc, err
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext___Field_type(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Type, nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
+ return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext___Field_type(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "__Field",
+ Field: field,
+ IsMethod: false,
+ IsResolver: false,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.childFields___Type(ctx, field)
+ },
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext___Field_isDeprecated(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.IsDeprecated(), nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v bool) graphql.Marshaler {
+ return ec.marshalNBoolean2bool(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext___Field_isDeprecated(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("__Field", field, true, false, errors.New("field of type Boolean does not have child fields"))
+}
+
+func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext___Field_deprecationReason(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.DeprecationReason(), nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v *string) graphql.Marshaler {
+ return ec.marshalOString2ᚖstring(ctx, selections, v)
+ },
+ true,
+ false,
+ )
+}
+func (ec *executionContext) fieldContext___Field_deprecationReason(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("__Field", field, true, false, errors.New("field of type String does not have child fields"))
+}
+
+func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext___InputValue_name(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Name, nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
+ return ec.marshalNString2string(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext___InputValue_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("__InputValue", field, false, false, errors.New("field of type String does not have child fields"))
+}
+
+func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext___InputValue_description(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Description(), nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v *string) graphql.Marshaler {
+ return ec.marshalOString2ᚖstring(ctx, selections, v)
+ },
+ true,
+ false,
+ )
+}
+func (ec *executionContext) fieldContext___InputValue_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("__InputValue", field, true, false, errors.New("field of type String does not have child fields"))
+}
+
+func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext___InputValue_type(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Type, nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
+ return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext___InputValue_type(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "__InputValue",
+ Field: field,
+ IsMethod: false,
+ IsResolver: false,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.childFields___Type(ctx, field)
+ },
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext___InputValue_defaultValue(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.DefaultValue, nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v *string) graphql.Marshaler {
+ return ec.marshalOString2ᚖstring(ctx, selections, v)
+ },
+ true,
+ false,
+ )
+}
+func (ec *executionContext) fieldContext___InputValue_defaultValue(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("__InputValue", field, false, false, errors.New("field of type String does not have child fields"))
+}
+
+func (ec *executionContext) ___InputValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext___InputValue_isDeprecated(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.IsDeprecated(), nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v bool) graphql.Marshaler {
+ return ec.marshalNBoolean2bool(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext___InputValue_isDeprecated(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("__InputValue", field, true, false, errors.New("field of type Boolean does not have child fields"))
+}
+
+func (ec *executionContext) ___InputValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext___InputValue_deprecationReason(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.DeprecationReason(), nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v *string) graphql.Marshaler {
+ return ec.marshalOString2ᚖstring(ctx, selections, v)
+ },
+ true,
+ false,
+ )
+}
+func (ec *executionContext) fieldContext___InputValue_deprecationReason(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("__InputValue", field, true, false, errors.New("field of type String does not have child fields"))
+}
+
+func (ec *executionContext) ___Schema_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext___Schema_description(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Description(), nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v *string) graphql.Marshaler {
+ return ec.marshalOString2ᚖstring(ctx, selections, v)
+ },
+ true,
+ false,
+ )
+}
+func (ec *executionContext) fieldContext___Schema_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("__Schema", field, true, false, errors.New("field of type String does not have child fields"))
+}
+
+func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext___Schema_types(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Types(), nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
+ return ec.marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext___Schema_types(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "__Schema",
+ Field: field,
+ IsMethod: true,
+ IsResolver: false,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.childFields___Type(ctx, field)
+ },
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext___Schema_queryType(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.QueryType(), nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
+ return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext___Schema_queryType(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "__Schema",
+ Field: field,
+ IsMethod: true,
+ IsResolver: false,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.childFields___Type(ctx, field)
+ },
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext___Schema_mutationType(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.MutationType(), nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
+ return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, selections, v)
+ },
+ true,
+ false,
+ )
+}
+func (ec *executionContext) fieldContext___Schema_mutationType(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "__Schema",
+ Field: field,
+ IsMethod: true,
+ IsResolver: false,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.childFields___Type(ctx, field)
+ },
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext___Schema_subscriptionType(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.SubscriptionType(), nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
+ return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, selections, v)
+ },
+ true,
+ false,
+ )
+}
+func (ec *executionContext) fieldContext___Schema_subscriptionType(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "__Schema",
+ Field: field,
+ IsMethod: true,
+ IsResolver: false,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.childFields___Type(ctx, field)
+ },
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext___Schema_directives(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Directives(), nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v []introspection.Directive) graphql.Marshaler {
+ return ec.marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext___Schema_directives(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "__Schema",
+ Field: field,
+ IsMethod: true,
+ IsResolver: false,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.childFields___Directive(ctx, field)
+ },
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext___Type_kind(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Kind(), nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v string) graphql.Marshaler {
+ return ec.marshalN__TypeKind2string(ctx, selections, v)
+ },
+ true,
+ true,
+ )
+}
+func (ec *executionContext) fieldContext___Type_kind(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("__Type", field, true, false, errors.New("field of type __TypeKind does not have child fields"))
+}
+
+func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext___Type_name(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Name(), nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v *string) graphql.Marshaler {
+ return ec.marshalOString2ᚖstring(ctx, selections, v)
+ },
+ true,
+ false,
+ )
+}
+func (ec *executionContext) fieldContext___Type_name(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("__Type", field, true, false, errors.New("field of type String does not have child fields"))
+}
+
+func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext___Type_description(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Description(), nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v *string) graphql.Marshaler {
+ return ec.marshalOString2ᚖstring(ctx, selections, v)
+ },
+ true,
+ false,
+ )
+}
+func (ec *executionContext) fieldContext___Type_description(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("__Type", field, true, false, errors.New("field of type String does not have child fields"))
+}
+
+func (ec *executionContext) ___Type_specifiedByURL(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext___Type_specifiedByURL(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.SpecifiedByURL(), nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v *string) graphql.Marshaler {
+ return ec.marshalOString2ᚖstring(ctx, selections, v)
+ },
+ true,
+ false,
+ )
+}
+func (ec *executionContext) fieldContext___Type_specifiedByURL(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("__Type", field, true, false, errors.New("field of type String does not have child fields"))
+}
+
+func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext___Type_fields(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ fc := graphql.GetFieldContext(ctx)
+ return obj.Fields(fc.Args["includeDeprecated"].(bool)), nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v []introspection.Field) graphql.Marshaler {
+ return ec.marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx, selections, v)
+ },
+ true,
+ false,
+ )
+}
+func (ec *executionContext) fieldContext___Type_fields(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "__Type",
+ Field: field,
+ IsMethod: true,
+ IsResolver: false,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.childFields___Field(ctx, field)
+ },
+ }
+ defer func() {
+ if r := recover(); r != nil {
+ err = ec.Recover(ctx, r)
+ ec.Error(ctx, err)
+ }
+ }()
+ ctx = graphql.WithFieldContext(ctx, fc)
+ if fc.Args, err = ec.field___Type_fields_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
+ ec.Error(ctx, err)
+ return fc, err
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext___Type_interfaces(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.Interfaces(), nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
+ return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, selections, v)
+ },
+ true,
+ false,
+ )
+}
+func (ec *executionContext) fieldContext___Type_interfaces(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "__Type",
+ Field: field,
+ IsMethod: true,
+ IsResolver: false,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.childFields___Type(ctx, field)
+ },
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext___Type_possibleTypes(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.PossibleTypes(), nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
+ return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, selections, v)
+ },
+ true,
+ false,
+ )
+}
+func (ec *executionContext) fieldContext___Type_possibleTypes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "__Type",
+ Field: field,
+ IsMethod: true,
+ IsResolver: false,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.childFields___Type(ctx, field)
+ },
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext___Type_enumValues(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ fc := graphql.GetFieldContext(ctx)
+ return obj.EnumValues(fc.Args["includeDeprecated"].(bool)), nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v []introspection.EnumValue) graphql.Marshaler {
+ return ec.marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx, selections, v)
+ },
+ true,
+ false,
+ )
+}
+func (ec *executionContext) fieldContext___Type_enumValues(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "__Type",
+ Field: field,
+ IsMethod: true,
+ IsResolver: false,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.childFields___EnumValue(ctx, field)
+ },
+ }
+ defer func() {
+ if r := recover(); r != nil {
+ err = ec.Recover(ctx, r)
+ ec.Error(ctx, err)
+ }
+ }()
+ ctx = graphql.WithFieldContext(ctx, fc)
+ if fc.Args, err = ec.field___Type_enumValues_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
+ ec.Error(ctx, err)
+ return fc, err
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext___Type_inputFields(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.InputFields(), nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
+ return ec.marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, selections, v)
+ },
+ true,
+ false,
+ )
+}
+func (ec *executionContext) fieldContext___Type_inputFields(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "__Type",
+ Field: field,
+ IsMethod: true,
+ IsResolver: false,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.childFields___InputValue(ctx, field)
+ },
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext___Type_ofType(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.OfType(), nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
+ return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, selections, v)
+ },
+ true,
+ false,
+ )
+}
+func (ec *executionContext) fieldContext___Type_ofType(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ fc = &graphql.FieldContext{
+ Object: "__Type",
+ Field: field,
+ IsMethod: true,
+ IsResolver: false,
+ Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.childFields___Type(ctx, field)
+ },
+ }
+ return fc, nil
+}
+
+func (ec *executionContext) ___Type_isOneOf(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
+ return graphql.ResolveField(
+ ctx,
+ ec.OperationContext,
+ field,
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
+ return ec.fieldContext___Type_isOneOf(ctx, field)
+ },
+ func(ctx context.Context) (any, error) {
+ return obj.IsOneOf(), nil
+ },
+ nil,
+ func(ctx context.Context, selections ast.SelectionSet, v bool) graphql.Marshaler {
+ return ec.marshalOBoolean2bool(ctx, selections, v)
+ },
+ true,
+ false,
+ )
+}
+func (ec *executionContext) fieldContext___Type_isOneOf(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
+ return graphql.NewScalarFieldContext("__Type", field, true, false, errors.New("field of type Boolean does not have child fields"))
+}
+
+// endregion **************************** field.gotpl *****************************
+
+// region **************************** input.gotpl *****************************
+
+func (ec *executionContext) unmarshalInputFilter(ctx context.Context, obj any) (model.Filter, error) {
+ var it model.Filter
+ if obj == nil {
+ return it, nil
+ }
+
+ asMap := map[string]any{}
+ for k, v := range obj.(map[string]any) {
+ asMap[k] = v
+ }
+
+ if _, present := asMap["count"]; !present {
+ asMap["count"] = 25
+ }
+
+ fieldsInOrder := [...]string{"count"}
+ for _, k := range fieldsInOrder {
+ v, ok := asMap[k]
+ if !ok {
+ continue
+ }
+ switch k {
+ case "count":
+ ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("count"))
+ data, err := ec.unmarshalOInt2ᚖint(ctx, v)
+ if err != nil {
+ return it, err
+ }
+ it.Count = data
+ }
+ }
+ return it, nil
+}
+
+// endregion **************************** input.gotpl *****************************
+
+// region ************************** interface.gotpl ***************************
+
+// endregion ************************** interface.gotpl ***************************
+
+// region **************************** object.gotpl ****************************
+
+var aCLEntryImplementors = []string{"ACLEntry"}
+
+func (ec *executionContext) _ACLEntry(ctx context.Context, sel ast.SelectionSet, obj *model1.ACLEntry) graphql.Marshaler {
+ fields := graphql.CollectFields(ec.OperationContext, sel, aCLEntryImplementors)
+
+ out := graphql.NewFieldSet(fields)
+ deferredFieldSet := graphql.NewFieldSet(nil)
+ deferLabelToView := make(map[string]*graphql.FieldSetView)
+ for i, field := range fields {
+ switch field.Name {
+ case "__typename":
+ out.Values[i] = graphql.MarshalString("ACLEntry")
+ case "user":
+ out.Values[i] = ec._ACLEntry_user(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "mode":
+ out.Values[i] = ec._ACLEntry_mode(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ default:
+ panic("unknown field " + strconv.Quote(field.Name))
+ }
+ }
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
+ return graphql.Null
+ }
+
+ atomic.AddInt32(&ec.Deferred, int32(min(len(deferLabelToView), math.MaxInt32)))
+
+ ec.ProcessDeferredGroup(graphql.DeferredGroup{
+ Defers: deferLabelToView,
+ Path: graphql.GetPath(ctx),
+ FieldSet: deferredFieldSet,
+ Context: ctx,
+ })
+
+ return out
+}
+
+var branchImplementors = []string{"Branch"}
+
+func (ec *executionContext) _Branch(ctx context.Context, sel ast.SelectionSet, obj *model1.Branch) graphql.Marshaler {
+ fields := graphql.CollectFields(ec.OperationContext, sel, branchImplementors)
+
+ out := graphql.NewFieldSet(fields)
+ deferredFieldSet := graphql.NewFieldSet(nil)
+ deferLabelToView := make(map[string]*graphql.FieldSetView)
+ for i, field := range fields {
+ switch field.Name {
+ case "__typename":
+ out.Values[i] = graphql.MarshalString("Branch")
+ case "name":
+ out.Values[i] = ec._Branch_name(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "head":
+ out.Values[i] = ec._Branch_head(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ default:
+ panic("unknown field " + strconv.Quote(field.Name))
+ }
+ }
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
+ return graphql.Null
+ }
+
+ atomic.AddInt32(&ec.Deferred, int32(min(len(deferLabelToView), math.MaxInt32)))
+
+ ec.ProcessDeferredGroup(graphql.DeferredGroup{
+ Defers: deferLabelToView,
+ Path: graphql.GetPath(ctx),
+ FieldSet: deferredFieldSet,
+ Context: ctx,
+ })
+
+ return out
+}
+
+var columnImplementors = []string{"Column"}
+
+func (ec *executionContext) _Column(ctx context.Context, sel ast.SelectionSet, obj *model1.Column) graphql.Marshaler {
+ fields := graphql.CollectFields(ec.OperationContext, sel, columnImplementors)
+
+ out := graphql.NewFieldSet(fields)
+ deferredFieldSet := graphql.NewFieldSet(nil)
+ deferLabelToView := make(map[string]*graphql.FieldSetView)
+ for i, field := range fields {
+ switch field.Name {
+ case "__typename":
+ out.Values[i] = graphql.MarshalString("Column")
+ case "name":
+ out.Values[i] = ec._Column_name(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "type":
+ out.Values[i] = ec._Column_type(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "primaryKey":
+ out.Values[i] = ec._Column_primaryKey(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "nullable":
+ out.Values[i] = ec._Column_nullable(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ default:
+ panic("unknown field " + strconv.Quote(field.Name))
+ }
+ }
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
+ return graphql.Null
+ }
+
+ atomic.AddInt32(&ec.Deferred, int32(min(len(deferLabelToView), math.MaxInt32)))
+
+ ec.ProcessDeferredGroup(graphql.DeferredGroup{
+ Defers: deferLabelToView,
+ Path: graphql.GetPath(ctx),
+ FieldSet: deferredFieldSet,
+ Context: ctx,
+ })
+
+ return out
+}
+
+var commitImplementors = []string{"Commit"}
+
+func (ec *executionContext) _Commit(ctx context.Context, sel ast.SelectionSet, obj *model1.Commit) graphql.Marshaler {
+ fields := graphql.CollectFields(ec.OperationContext, sel, commitImplementors)
+
+ out := graphql.NewFieldSet(fields)
+ deferredFieldSet := graphql.NewFieldSet(nil)
+ deferLabelToView := make(map[string]*graphql.FieldSetView)
+ for i, field := range fields {
+ switch field.Name {
+ case "__typename":
+ out.Values[i] = graphql.MarshalString("Commit")
+ case "hash":
+ out.Values[i] = ec._Commit_hash(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "author":
+ out.Values[i] = ec._Commit_author(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "email":
+ out.Values[i] = ec._Commit_email(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "date":
+ out.Values[i] = ec._Commit_date(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "message":
+ out.Values[i] = ec._Commit_message(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "parents":
+ out.Values[i] = ec._Commit_parents(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ default:
+ panic("unknown field " + strconv.Quote(field.Name))
+ }
+ }
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
+ return graphql.Null
+ }
+
+ atomic.AddInt32(&ec.Deferred, int32(min(len(deferLabelToView), math.MaxInt32)))
+
+ ec.ProcessDeferredGroup(graphql.DeferredGroup{
+ Defers: deferLabelToView,
+ Path: graphql.GetPath(ctx),
+ FieldSet: deferredFieldSet,
+ Context: ctx,
+ })
+
+ return out
+}
+
+var commitCursorImplementors = []string{"CommitCursor"}
+
+func (ec *executionContext) _CommitCursor(ctx context.Context, sel ast.SelectionSet, obj *model1.CommitCursor) graphql.Marshaler {
+ fields := graphql.CollectFields(ec.OperationContext, sel, commitCursorImplementors)
+
+ out := graphql.NewFieldSet(fields)
+ deferredFieldSet := graphql.NewFieldSet(nil)
+ deferLabelToView := make(map[string]*graphql.FieldSetView)
+ for i, field := range fields {
+ switch field.Name {
+ case "__typename":
+ out.Values[i] = graphql.MarshalString("CommitCursor")
+ case "results":
+ out.Values[i] = ec._CommitCursor_results(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "cursor":
+ out.Values[i] = ec._CommitCursor_cursor(ctx, field, obj)
+ if out.Values[i] == graphql.RequiredNull {
+ out.Invalids++
+ }
+ default:
+ panic("unknown field " + strconv.Quote(field.Name))
+ }
+ }
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
+ return graphql.Null
+ }
+
+ atomic.AddInt32(&ec.Deferred, int32(min(len(deferLabelToView), math.MaxInt32)))
+
+ ec.ProcessDeferredGroup(graphql.DeferredGroup{
+ Defers: deferLabelToView,
+ Path: graphql.GetPath(ctx),
+ FieldSet: deferredFieldSet,
+ Context: ctx,
+ })
+
+ return out
+}
+
+var databaseImplementors = []string{"Database"}
+
+func (ec *executionContext) _Database(ctx context.Context, sel ast.SelectionSet, obj *model1.Database) graphql.Marshaler {
+ fields := graphql.CollectFields(ec.OperationContext, sel, databaseImplementors)
+
+ out := graphql.NewFieldSet(fields)
+ deferredFieldSet := graphql.NewFieldSet(nil)
+ deferLabelToView := make(map[string]*graphql.FieldSetView)
+ for i, field := range fields {
+ switch field.Name {
+ case "__typename":
+ out.Values[i] = graphql.MarshalString("Database")
+ case "id":
+ out.Values[i] = ec._Database_id(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ atomic.AddUint32(&out.Invalids, 1)
+ }
+ case "name":
+ out.Values[i] = ec._Database_name(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ atomic.AddUint32(&out.Invalids, 1)
+ }
+ case "owner":
+ out.Values[i] = ec._Database_owner(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ atomic.AddUint32(&out.Invalids, 1)
+ }
+ case "description":
+ out.Values[i] = ec._Database_description(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ atomic.AddUint32(&out.Invalids, 1)
+ }
+ case "visibility":
+ out.Values[i] = ec._Database_visibility(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ atomic.AddUint32(&out.Invalids, 1)
+ }
+ case "created":
+ out.Values[i] = ec._Database_created(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ atomic.AddUint32(&out.Invalids, 1)
+ }
+ case "updated":
+ out.Values[i] = ec._Database_updated(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ atomic.AddUint32(&out.Invalids, 1)
+ }
+ case "defaultBranch":
+ field := field
+
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
+ defer func() {
+ if r := recover(); r != nil {
+ ec.Error(ctx, ec.Recover(ctx, r))
+ }
+ }()
+ res = ec._Database_defaultBranch(ctx, field, obj)
+ if res == graphql.RequiredNull {
+ atomic.AddUint32(&fs.Invalids, 1)
+ }
+ return res
+ }
+
+ if field.IsDeferred() {
+ deferredFieldSet.AddField(field)
+ fieldIndex := len(deferredFieldSet.Values) - 1
+ deferredFieldSet.Concurrently(fieldIndex, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, deferredFieldSet)
+ })
+
+ for _, deferrable := range field.Deferrables {
+ view, ok := deferLabelToView[deferrable.Label]
+ if !ok {
+ view = deferredFieldSet.NewView()
+ deferLabelToView[deferrable.Label] = view
+ }
+ view.AddIndices(fieldIndex)
+ }
+
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
+
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
+ case "branches":
+ field := field
+
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
+ defer func() {
+ if r := recover(); r != nil {
+ ec.Error(ctx, ec.Recover(ctx, r))
+ }
+ }()
+ res = ec._Database_branches(ctx, field, obj)
+ if res == graphql.Null {
+ atomic.AddUint32(&fs.Invalids, 1)
+ }
+ return res
+ }
+
+ if field.IsDeferred() {
+ deferredFieldSet.AddField(field)
+ fieldIndex := len(deferredFieldSet.Values) - 1
+ deferredFieldSet.Concurrently(fieldIndex, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, deferredFieldSet)
+ })
+
+ for _, deferrable := range field.Deferrables {
+ view, ok := deferLabelToView[deferrable.Label]
+ if !ok {
+ view = deferredFieldSet.NewView()
+ deferLabelToView[deferrable.Label] = view
+ }
+ view.AddIndices(fieldIndex)
+ }
+
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
+
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
+ case "log":
+ field := field
+
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
+ defer func() {
+ if r := recover(); r != nil {
+ ec.Error(ctx, ec.Recover(ctx, r))
+ }
+ }()
+ res = ec._Database_log(ctx, field, obj)
+ if res == graphql.Null {
+ atomic.AddUint32(&fs.Invalids, 1)
+ }
+ return res
+ }
+
+ if field.IsDeferred() {
+ deferredFieldSet.AddField(field)
+ fieldIndex := len(deferredFieldSet.Values) - 1
+ deferredFieldSet.Concurrently(fieldIndex, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, deferredFieldSet)
+ })
+
+ for _, deferrable := range field.Deferrables {
+ view, ok := deferLabelToView[deferrable.Label]
+ if !ok {
+ view = deferredFieldSet.NewView()
+ deferLabelToView[deferrable.Label] = view
+ }
+ view.AddIndices(fieldIndex)
+ }
+
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
+
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
+ case "tables":
+ field := field
+
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
+ defer func() {
+ if r := recover(); r != nil {
+ ec.Error(ctx, ec.Recover(ctx, r))
+ }
+ }()
+ res = ec._Database_tables(ctx, field, obj)
+ if res == graphql.Null {
+ atomic.AddUint32(&fs.Invalids, 1)
+ }
+ return res
+ }
+
+ if field.IsDeferred() {
+ deferredFieldSet.AddField(field)
+ fieldIndex := len(deferredFieldSet.Values) - 1
+ deferredFieldSet.Concurrently(fieldIndex, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, deferredFieldSet)
+ })
+
+ for _, deferrable := range field.Deferrables {
+ view, ok := deferLabelToView[deferrable.Label]
+ if !ok {
+ view = deferredFieldSet.NewView()
+ deferLabelToView[deferrable.Label] = view
+ }
+ view.AddIndices(fieldIndex)
+ }
+
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
+
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
+ case "acl":
+ field := field
+
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
+ defer func() {
+ if r := recover(); r != nil {
+ ec.Error(ctx, ec.Recover(ctx, r))
+ }
+ }()
+ res = ec._Database_acl(ctx, field, obj)
+ if res == graphql.Null {
+ atomic.AddUint32(&fs.Invalids, 1)
+ }
+ return res
+ }
+
+ if field.IsDeferred() {
+ deferredFieldSet.AddField(field)
+ fieldIndex := len(deferredFieldSet.Values) - 1
+ deferredFieldSet.Concurrently(fieldIndex, func(ctx context.Context) graphql.Marshaler {
+ return innerFunc(ctx, deferredFieldSet)
+ })
+
+ for _, deferrable := range field.Deferrables {
+ view, ok := deferLabelToView[deferrable.Label]
+ if !ok {
+ view = deferredFieldSet.NewView()
+ deferLabelToView[deferrable.Label] = view
+ }
+ view.AddIndices(fieldIndex)
+ }
+
+ // don't run the out.Concurrently() call below
+ out.Values[i] = graphql.Null
+ continue
+ }
+
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
+ default:
+ panic("unknown field " + strconv.Quote(field.Name))
+ }
+ }
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
+ return graphql.Null
+ }
+
+ atomic.AddInt32(&ec.Deferred, int32(min(len(deferLabelToView), math.MaxInt32)))
+
+ ec.ProcessDeferredGroup(graphql.DeferredGroup{
+ Defers: deferLabelToView,
+ Path: graphql.GetPath(ctx),
+ FieldSet: deferredFieldSet,
+ Context: ctx,
+ })
+
+ return out
+}
+
+var databaseCursorImplementors = []string{"DatabaseCursor"}
+
+func (ec *executionContext) _DatabaseCursor(ctx context.Context, sel ast.SelectionSet, obj *model1.DatabaseCursor) graphql.Marshaler {
+ fields := graphql.CollectFields(ec.OperationContext, sel, databaseCursorImplementors)
+
+ out := graphql.NewFieldSet(fields)
+ deferredFieldSet := graphql.NewFieldSet(nil)
+ deferLabelToView := make(map[string]*graphql.FieldSetView)
+ for i, field := range fields {
+ switch field.Name {
+ case "__typename":
+ out.Values[i] = graphql.MarshalString("DatabaseCursor")
+ case "results":
+ out.Values[i] = ec._DatabaseCursor_results(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "cursor":
+ out.Values[i] = ec._DatabaseCursor_cursor(ctx, field, obj)
+ if out.Values[i] == graphql.RequiredNull {
+ out.Invalids++
+ }
+ default:
+ panic("unknown field " + strconv.Quote(field.Name))
+ }
+ }
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
+ return graphql.Null
+ }
+
+ atomic.AddInt32(&ec.Deferred, int32(min(len(deferLabelToView), math.MaxInt32)))
+
+ ec.ProcessDeferredGroup(graphql.DeferredGroup{
+ Defers: deferLabelToView,
+ Path: graphql.GetPath(ctx),
+ FieldSet: deferredFieldSet,
+ Context: ctx,
+ })
+
+ return out
+}
+
+var queryImplementors = []string{"Query"}
+
+func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
+ fields := graphql.CollectFields(ec.OperationContext, sel, queryImplementors)
+ ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
+ Object: "Query",
+ })
+
+ out := graphql.NewFieldSet(fields)
+ deferredFieldSet := graphql.NewFieldSet(nil)
+ deferLabelToView := make(map[string]*graphql.FieldSetView)
+ for i, field := range fields {
+ innerCtx := graphql.WithRootFieldContext(ctx, &graphql.RootFieldContext{
+ Object: field.Name,
+ Field: field,
+ })
+
+ switch field.Name {
+ case "__typename":
+ out.Values[i] = graphql.MarshalString("Query")
+ case "me":
+ field := field
+
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
+ defer func() {
+ if r := recover(); r != nil {
+ ec.Error(ctx, ec.Recover(ctx, r))
+ }
+ }()
+ res = ec._Query_me(ctx, field)
+ if res == graphql.RequiredNull {
+ atomic.AddUint32(&fs.Invalids, 1)
+ }
+ return res
+ }
+
+ rrm := func(ctx context.Context) graphql.Marshaler {
+ return ec.OperationContext.RootResolverMiddleware(ctx,
+ func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
+ }
+
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
+ case "databases":
+ field := field
+
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
+ defer func() {
+ if r := recover(); r != nil {
+ ec.Error(ctx, ec.Recover(ctx, r))
+ }
+ }()
+ res = ec._Query_databases(ctx, field)
+ if res == graphql.Null {
+ atomic.AddUint32(&fs.Invalids, 1)
+ }
+ return res
+ }
+
+ rrm := func(ctx context.Context) graphql.Marshaler {
+ return ec.OperationContext.RootResolverMiddleware(ctx,
+ func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
+ }
+
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
+ case "databasesByOwner":
+ field := field
+
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
+ defer func() {
+ if r := recover(); r != nil {
+ ec.Error(ctx, ec.Recover(ctx, r))
+ }
+ }()
+ res = ec._Query_databasesByOwner(ctx, field)
+ if res == graphql.Null {
+ atomic.AddUint32(&fs.Invalids, 1)
+ }
+ return res
+ }
+
+ rrm := func(ctx context.Context) graphql.Marshaler {
+ return ec.OperationContext.RootResolverMiddleware(ctx,
+ func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
+ }
+
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
+ case "database":
+ field := field
+
+ innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
+ defer func() {
+ if r := recover(); r != nil {
+ ec.Error(ctx, ec.Recover(ctx, r))
+ }
+ }()
+ res = ec._Query_database(ctx, field)
+ if res == graphql.RequiredNull {
+ atomic.AddUint32(&fs.Invalids, 1)
+ }
+ return res
+ }
+
+ rrm := func(ctx context.Context) graphql.Marshaler {
+ return ec.OperationContext.RootResolverMiddleware(ctx,
+ func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
+ }
+
+ out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) })
+ case "__type":
+ out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
+ return ec._Query___type(ctx, field)
+ })
+ if out.Values[i] == graphql.RequiredNull {
+ atomic.AddUint32(&out.Invalids, 1)
+ }
+ case "__schema":
+ out.Values[i] = ec.OperationContext.RootResolverMiddleware(innerCtx, func(ctx context.Context) (res graphql.Marshaler) {
+ return ec._Query___schema(ctx, field)
+ })
+ if out.Values[i] == graphql.RequiredNull {
+ atomic.AddUint32(&out.Invalids, 1)
+ }
+ default:
+ panic("unknown field " + strconv.Quote(field.Name))
+ }
+ }
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
+ return graphql.Null
+ }
+
+ atomic.AddInt32(&ec.Deferred, int32(min(len(deferLabelToView), math.MaxInt32)))
+
+ ec.ProcessDeferredGroup(graphql.DeferredGroup{
+ Defers: deferLabelToView,
+ Path: graphql.GetPath(ctx),
+ FieldSet: deferredFieldSet,
+ Context: ctx,
+ })
+
+ return out
+}
+
+var tableImplementors = []string{"Table"}
+
+func (ec *executionContext) _Table(ctx context.Context, sel ast.SelectionSet, obj *model1.Table) graphql.Marshaler {
+ fields := graphql.CollectFields(ec.OperationContext, sel, tableImplementors)
+
+ out := graphql.NewFieldSet(fields)
+ deferredFieldSet := graphql.NewFieldSet(nil)
+ deferLabelToView := make(map[string]*graphql.FieldSetView)
+ for i, field := range fields {
+ switch field.Name {
+ case "__typename":
+ out.Values[i] = graphql.MarshalString("Table")
+ case "name":
+ out.Values[i] = ec._Table_name(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "columns":
+ out.Values[i] = ec._Table_columns(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "rowCount":
+ out.Values[i] = ec._Table_rowCount(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ default:
+ panic("unknown field " + strconv.Quote(field.Name))
+ }
+ }
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
+ return graphql.Null
+ }
+
+ atomic.AddInt32(&ec.Deferred, int32(min(len(deferLabelToView), math.MaxInt32)))
+
+ ec.ProcessDeferredGroup(graphql.DeferredGroup{
+ Defers: deferLabelToView,
+ Path: graphql.GetPath(ctx),
+ FieldSet: deferredFieldSet,
+ Context: ctx,
+ })
+
+ return out
+}
+
+var userImplementors = []string{"User"}
+
+func (ec *executionContext) _User(ctx context.Context, sel ast.SelectionSet, obj *model1.User) graphql.Marshaler {
+ fields := graphql.CollectFields(ec.OperationContext, sel, userImplementors)
+
+ out := graphql.NewFieldSet(fields)
+ deferredFieldSet := graphql.NewFieldSet(nil)
+ deferLabelToView := make(map[string]*graphql.FieldSetView)
+ for i, field := range fields {
+ switch field.Name {
+ case "__typename":
+ out.Values[i] = graphql.MarshalString("User")
+ case "username":
+ out.Values[i] = ec._User_username(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "canonicalName":
+ out.Values[i] = ec._User_canonicalName(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ default:
+ panic("unknown field " + strconv.Quote(field.Name))
+ }
+ }
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
+ return graphql.Null
+ }
+
+ atomic.AddInt32(&ec.Deferred, int32(min(len(deferLabelToView), math.MaxInt32)))
+
+ ec.ProcessDeferredGroup(graphql.DeferredGroup{
+ Defers: deferLabelToView,
+ Path: graphql.GetPath(ctx),
+ FieldSet: deferredFieldSet,
+ Context: ctx,
+ })
+
+ return out
+}
+
+var __DirectiveImplementors = []string{"__Directive"}
+
+func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler {
+ fields := graphql.CollectFields(ec.OperationContext, sel, __DirectiveImplementors)
+
+ out := graphql.NewFieldSet(fields)
+ deferredFieldSet := graphql.NewFieldSet(nil)
+ deferLabelToView := make(map[string]*graphql.FieldSetView)
+ for i, field := range fields {
+ switch field.Name {
+ case "__typename":
+ out.Values[i] = graphql.MarshalString("__Directive")
+ case "name":
+ out.Values[i] = ec.___Directive_name(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "description":
+ out.Values[i] = ec.___Directive_description(ctx, field, obj)
+ if out.Values[i] == graphql.RequiredNull {
+ out.Invalids++
+ }
+ case "isRepeatable":
+ out.Values[i] = ec.___Directive_isRepeatable(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "locations":
+ out.Values[i] = ec.___Directive_locations(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "args":
+ out.Values[i] = ec.___Directive_args(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ default:
+ panic("unknown field " + strconv.Quote(field.Name))
+ }
+ }
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
+ return graphql.Null
+ }
+
+ atomic.AddInt32(&ec.Deferred, int32(min(len(deferLabelToView), math.MaxInt32)))
+
+ ec.ProcessDeferredGroup(graphql.DeferredGroup{
+ Defers: deferLabelToView,
+ Path: graphql.GetPath(ctx),
+ FieldSet: deferredFieldSet,
+ Context: ctx,
+ })
+
+ return out
+}
+
+var __EnumValueImplementors = []string{"__EnumValue"}
+
+func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler {
+ fields := graphql.CollectFields(ec.OperationContext, sel, __EnumValueImplementors)
+
+ out := graphql.NewFieldSet(fields)
+ deferredFieldSet := graphql.NewFieldSet(nil)
+ deferLabelToView := make(map[string]*graphql.FieldSetView)
+ for i, field := range fields {
+ switch field.Name {
+ case "__typename":
+ out.Values[i] = graphql.MarshalString("__EnumValue")
+ case "name":
+ out.Values[i] = ec.___EnumValue_name(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "description":
+ out.Values[i] = ec.___EnumValue_description(ctx, field, obj)
+ if out.Values[i] == graphql.RequiredNull {
+ out.Invalids++
+ }
+ case "isDeprecated":
+ out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "deprecationReason":
+ out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj)
+ if out.Values[i] == graphql.RequiredNull {
+ out.Invalids++
+ }
+ default:
+ panic("unknown field " + strconv.Quote(field.Name))
+ }
+ }
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
+ return graphql.Null
+ }
+
+ atomic.AddInt32(&ec.Deferred, int32(min(len(deferLabelToView), math.MaxInt32)))
+
+ ec.ProcessDeferredGroup(graphql.DeferredGroup{
+ Defers: deferLabelToView,
+ Path: graphql.GetPath(ctx),
+ FieldSet: deferredFieldSet,
+ Context: ctx,
+ })
+
+ return out
+}
+
+var __FieldImplementors = []string{"__Field"}
+
+func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler {
+ fields := graphql.CollectFields(ec.OperationContext, sel, __FieldImplementors)
+
+ out := graphql.NewFieldSet(fields)
+ deferredFieldSet := graphql.NewFieldSet(nil)
+ deferLabelToView := make(map[string]*graphql.FieldSetView)
+ for i, field := range fields {
+ switch field.Name {
+ case "__typename":
+ out.Values[i] = graphql.MarshalString("__Field")
+ case "name":
+ out.Values[i] = ec.___Field_name(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "description":
+ out.Values[i] = ec.___Field_description(ctx, field, obj)
+ if out.Values[i] == graphql.RequiredNull {
+ out.Invalids++
+ }
+ case "args":
+ out.Values[i] = ec.___Field_args(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "type":
+ out.Values[i] = ec.___Field_type(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "isDeprecated":
+ out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "deprecationReason":
+ out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj)
+ if out.Values[i] == graphql.RequiredNull {
+ out.Invalids++
+ }
+ default:
+ panic("unknown field " + strconv.Quote(field.Name))
+ }
+ }
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
+ return graphql.Null
+ }
+
+ atomic.AddInt32(&ec.Deferred, int32(min(len(deferLabelToView), math.MaxInt32)))
+
+ ec.ProcessDeferredGroup(graphql.DeferredGroup{
+ Defers: deferLabelToView,
+ Path: graphql.GetPath(ctx),
+ FieldSet: deferredFieldSet,
+ Context: ctx,
+ })
+
+ return out
+}
+
+var __InputValueImplementors = []string{"__InputValue"}
+
+func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler {
+ fields := graphql.CollectFields(ec.OperationContext, sel, __InputValueImplementors)
+
+ out := graphql.NewFieldSet(fields)
+ deferredFieldSet := graphql.NewFieldSet(nil)
+ deferLabelToView := make(map[string]*graphql.FieldSetView)
+ for i, field := range fields {
+ switch field.Name {
+ case "__typename":
+ out.Values[i] = graphql.MarshalString("__InputValue")
+ case "name":
+ out.Values[i] = ec.___InputValue_name(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "description":
+ out.Values[i] = ec.___InputValue_description(ctx, field, obj)
+ if out.Values[i] == graphql.RequiredNull {
+ out.Invalids++
+ }
+ case "type":
+ out.Values[i] = ec.___InputValue_type(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "defaultValue":
+ out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj)
+ if out.Values[i] == graphql.RequiredNull {
+ out.Invalids++
+ }
+ case "isDeprecated":
+ out.Values[i] = ec.___InputValue_isDeprecated(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "deprecationReason":
+ out.Values[i] = ec.___InputValue_deprecationReason(ctx, field, obj)
+ if out.Values[i] == graphql.RequiredNull {
+ out.Invalids++
+ }
+ default:
+ panic("unknown field " + strconv.Quote(field.Name))
+ }
+ }
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
+ return graphql.Null
+ }
+
+ atomic.AddInt32(&ec.Deferred, int32(min(len(deferLabelToView), math.MaxInt32)))
+
+ ec.ProcessDeferredGroup(graphql.DeferredGroup{
+ Defers: deferLabelToView,
+ Path: graphql.GetPath(ctx),
+ FieldSet: deferredFieldSet,
+ Context: ctx,
+ })
+
+ return out
+}
+
+var __SchemaImplementors = []string{"__Schema"}
+
+func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler {
+ fields := graphql.CollectFields(ec.OperationContext, sel, __SchemaImplementors)
+
+ out := graphql.NewFieldSet(fields)
+ deferredFieldSet := graphql.NewFieldSet(nil)
+ deferLabelToView := make(map[string]*graphql.FieldSetView)
+ for i, field := range fields {
+ switch field.Name {
+ case "__typename":
+ out.Values[i] = graphql.MarshalString("__Schema")
+ case "description":
+ out.Values[i] = ec.___Schema_description(ctx, field, obj)
+ if out.Values[i] == graphql.RequiredNull {
+ out.Invalids++
+ }
+ case "types":
+ out.Values[i] = ec.___Schema_types(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "queryType":
+ out.Values[i] = ec.___Schema_queryType(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "mutationType":
+ out.Values[i] = ec.___Schema_mutationType(ctx, field, obj)
+ if out.Values[i] == graphql.RequiredNull {
+ out.Invalids++
+ }
+ case "subscriptionType":
+ out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj)
+ if out.Values[i] == graphql.RequiredNull {
+ out.Invalids++
+ }
+ case "directives":
+ out.Values[i] = ec.___Schema_directives(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ default:
+ panic("unknown field " + strconv.Quote(field.Name))
+ }
+ }
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
+ return graphql.Null
+ }
+
+ atomic.AddInt32(&ec.Deferred, int32(min(len(deferLabelToView), math.MaxInt32)))
+
+ ec.ProcessDeferredGroup(graphql.DeferredGroup{
+ Defers: deferLabelToView,
+ Path: graphql.GetPath(ctx),
+ FieldSet: deferredFieldSet,
+ Context: ctx,
+ })
+
+ return out
+}
+
+var __TypeImplementors = []string{"__Type"}
+
+func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler {
+ fields := graphql.CollectFields(ec.OperationContext, sel, __TypeImplementors)
+
+ out := graphql.NewFieldSet(fields)
+ deferredFieldSet := graphql.NewFieldSet(nil)
+ deferLabelToView := make(map[string]*graphql.FieldSetView)
+ for i, field := range fields {
+ switch field.Name {
+ case "__typename":
+ out.Values[i] = graphql.MarshalString("__Type")
+ case "kind":
+ out.Values[i] = ec.___Type_kind(ctx, field, obj)
+ if out.Values[i] == graphql.Null {
+ out.Invalids++
+ }
+ case "name":
+ out.Values[i] = ec.___Type_name(ctx, field, obj)
+ if out.Values[i] == graphql.RequiredNull {
+ out.Invalids++
+ }
+ case "description":
+ out.Values[i] = ec.___Type_description(ctx, field, obj)
+ if out.Values[i] == graphql.RequiredNull {
+ out.Invalids++
+ }
+ case "specifiedByURL":
+ out.Values[i] = ec.___Type_specifiedByURL(ctx, field, obj)
+ if out.Values[i] == graphql.RequiredNull {
+ out.Invalids++
+ }
+ case "fields":
+ out.Values[i] = ec.___Type_fields(ctx, field, obj)
+ if out.Values[i] == graphql.RequiredNull {
+ out.Invalids++
+ }
+ case "interfaces":
+ out.Values[i] = ec.___Type_interfaces(ctx, field, obj)
+ if out.Values[i] == graphql.RequiredNull {
+ out.Invalids++
+ }
+ case "possibleTypes":
+ out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj)
+ if out.Values[i] == graphql.RequiredNull {
+ out.Invalids++
+ }
+ case "enumValues":
+ out.Values[i] = ec.___Type_enumValues(ctx, field, obj)
+ if out.Values[i] == graphql.RequiredNull {
+ out.Invalids++
+ }
+ case "inputFields":
+ out.Values[i] = ec.___Type_inputFields(ctx, field, obj)
+ if out.Values[i] == graphql.RequiredNull {
+ out.Invalids++
+ }
+ case "ofType":
+ out.Values[i] = ec.___Type_ofType(ctx, field, obj)
+ if out.Values[i] == graphql.RequiredNull {
+ out.Invalids++
+ }
+ case "isOneOf":
+ out.Values[i] = ec.___Type_isOneOf(ctx, field, obj)
+ if out.Values[i] == graphql.RequiredNull {
+ out.Invalids++
+ }
+ default:
+ panic("unknown field " + strconv.Quote(field.Name))
+ }
+ }
+ out.Dispatch(ctx)
+ if out.Invalids > 0 {
+ return graphql.Null
+ }
+
+ atomic.AddInt32(&ec.Deferred, int32(min(len(deferLabelToView), math.MaxInt32)))
+
+ ec.ProcessDeferredGroup(graphql.DeferredGroup{
+ Defers: deferLabelToView,
+ Path: graphql.GetPath(ctx),
+ FieldSet: deferredFieldSet,
+ Context: ctx,
+ })
+
+ return out
+}
+
+// endregion **************************** object.gotpl ****************************
+
+// region ***************************** type.gotpl *****************************
+
+func (ec *executionContext) marshalNACLEntry2ᚕᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐACLEntryᚄ(ctx context.Context, sel ast.SelectionSet, v []*model1.ACLEntry) graphql.Marshaler {
+ ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler {
+ fc := graphql.GetFieldContext(ctx)
+ fc.Result = &v[i]
+ return ec.marshalNACLEntry2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐACLEntry(ctx, sel, v[i])
+ })
+
+ for _, e := range ret {
+ if e == graphql.Null {
+ return graphql.Null
+ }
+ }
+
+ return ret
+}
+
+func (ec *executionContext) marshalNACLEntry2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐACLEntry(ctx context.Context, sel ast.SelectionSet, v *model1.ACLEntry) graphql.Marshaler {
+ if v == nil {
+ if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
+ graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
+ }
+ return graphql.Null
+ }
+ return ec._ACLEntry(ctx, sel, v)
+}
+
+func (ec *executionContext) unmarshalNAccessMode2sourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐAccessMode(ctx context.Context, v any) (model1.AccessMode, error) {
+ var res model1.AccessMode
+ err := res.UnmarshalGQL(v)
+ return res, graphql.ErrorOnPath(ctx, err)
+}
+
+func (ec *executionContext) marshalNAccessMode2sourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐAccessMode(ctx context.Context, sel ast.SelectionSet, v model1.AccessMode) graphql.Marshaler {
+ return v
+}
+
+func (ec *executionContext) unmarshalNBoolean2bool(ctx context.Context, v any) (bool, error) {
+ res, err := graphql.UnmarshalBoolean(v)
+ return res, graphql.ErrorOnPath(ctx, err)
+}
+
+func (ec *executionContext) marshalNBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
+ _ = sel
+ res := graphql.MarshalBoolean(v)
+ if res == graphql.Null {
+ if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
+ graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
+ }
+ }
+ return res
+}
+
+func (ec *executionContext) marshalNBranch2ᚕᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐBranchᚄ(ctx context.Context, sel ast.SelectionSet, v []*model1.Branch) graphql.Marshaler {
+ ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler {
+ fc := graphql.GetFieldContext(ctx)
+ fc.Result = &v[i]
+ return ec.marshalNBranch2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐBranch(ctx, sel, v[i])
+ })
+
+ for _, e := range ret {
+ if e == graphql.Null {
+ return graphql.Null
+ }
+ }
+
+ return ret
+}
+
+func (ec *executionContext) marshalNBranch2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐBranch(ctx context.Context, sel ast.SelectionSet, v *model1.Branch) graphql.Marshaler {
+ if v == nil {
+ if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
+ graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
+ }
+ return graphql.Null
+ }
+ return ec._Branch(ctx, sel, v)
+}
+
+func (ec *executionContext) marshalNColumn2ᚕᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐColumnᚄ(ctx context.Context, sel ast.SelectionSet, v []*model1.Column) graphql.Marshaler {
+ ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler {
+ fc := graphql.GetFieldContext(ctx)
+ fc.Result = &v[i]
+ return ec.marshalNColumn2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐColumn(ctx, sel, v[i])
+ })
+
+ for _, e := range ret {
+ if e == graphql.Null {
+ return graphql.Null
+ }
+ }
+
+ return ret
+}
+
+func (ec *executionContext) marshalNColumn2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐColumn(ctx context.Context, sel ast.SelectionSet, v *model1.Column) graphql.Marshaler {
+ if v == nil {
+ if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
+ graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
+ }
+ return graphql.Null
+ }
+ return ec._Column(ctx, sel, v)
+}
+
+func (ec *executionContext) marshalNCommit2ᚕᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐCommitᚄ(ctx context.Context, sel ast.SelectionSet, v []*model1.Commit) graphql.Marshaler {
+ ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler {
+ fc := graphql.GetFieldContext(ctx)
+ fc.Result = &v[i]
+ return ec.marshalNCommit2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐCommit(ctx, sel, v[i])
+ })
+
+ for _, e := range ret {
+ if e == graphql.Null {
+ return graphql.Null
+ }
+ }
+
+ return ret
+}
+
+func (ec *executionContext) marshalNCommit2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐCommit(ctx context.Context, sel ast.SelectionSet, v *model1.Commit) graphql.Marshaler {
+ if v == nil {
+ if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
+ graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
+ }
+ return graphql.Null
+ }
+ return ec._Commit(ctx, sel, v)
+}
+
+func (ec *executionContext) marshalNCommitCursor2sourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐCommitCursor(ctx context.Context, sel ast.SelectionSet, v model1.CommitCursor) graphql.Marshaler {
+ return ec._CommitCursor(ctx, sel, &v)
+}
+
+func (ec *executionContext) marshalNCommitCursor2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐCommitCursor(ctx context.Context, sel ast.SelectionSet, v *model1.CommitCursor) graphql.Marshaler {
+ if v == nil {
+ if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
+ graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
+ }
+ return graphql.Null
+ }
+ return ec._CommitCursor(ctx, sel, v)
+}
+
+func (ec *executionContext) marshalNDatabase2ᚕᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐDatabaseᚄ(ctx context.Context, sel ast.SelectionSet, v []*model1.Database) graphql.Marshaler {
+ ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler {
+ fc := graphql.GetFieldContext(ctx)
+ fc.Result = &v[i]
+ return ec.marshalNDatabase2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐDatabase(ctx, sel, v[i])
+ })
+
+ for _, e := range ret {
+ if e == graphql.Null {
+ return graphql.Null
+ }
+ }
+
+ return ret
+}
+
+func (ec *executionContext) marshalNDatabase2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐDatabase(ctx context.Context, sel ast.SelectionSet, v *model1.Database) graphql.Marshaler {
+ if v == nil {
+ if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
+ graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
+ }
+ return graphql.Null
+ }
+ return ec._Database(ctx, sel, v)
+}
+
+func (ec *executionContext) marshalNDatabaseCursor2sourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐDatabaseCursor(ctx context.Context, sel ast.SelectionSet, v model1.DatabaseCursor) graphql.Marshaler {
+ return ec._DatabaseCursor(ctx, sel, &v)
+}
+
+func (ec *executionContext) marshalNDatabaseCursor2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐDatabaseCursor(ctx context.Context, sel ast.SelectionSet, v *model1.DatabaseCursor) graphql.Marshaler {
+ if v == nil {
+ if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
+ graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
+ }
+ return graphql.Null
+ }
+ return ec._DatabaseCursor(ctx, sel, v)
+}
+
+func (ec *executionContext) unmarshalNInt2int(ctx context.Context, v any) (int, error) {
+ res, err := graphql.UnmarshalInt(v)
+ return res, graphql.ErrorOnPath(ctx, err)
+}
+
+func (ec *executionContext) marshalNInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
+ _ = sel
+ res := graphql.MarshalInt(v)
+ if res == graphql.Null {
+ if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
+ graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
+ }
+ }
+ return res
+}
+
+func (ec *executionContext) unmarshalNString2string(ctx context.Context, v any) (string, error) {
+ res, err := graphql.UnmarshalString(v)
+ return res, graphql.ErrorOnPath(ctx, err)
+}
+
+func (ec *executionContext) marshalNString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
+ _ = sel
+ res := graphql.MarshalString(v)
+ if res == graphql.Null {
+ if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
+ graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
+ }
+ }
+ return res
+}
+
+func (ec *executionContext) unmarshalNString2ᚕstringᚄ(ctx context.Context, v any) ([]string, error) {
+ vSlice := graphql.CoerceList(v)
+ var err error
+ res := make([]string, len(vSlice))
+ for i := range vSlice {
+ ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
+ res[i], err = ec.unmarshalNString2string(ctx, vSlice[i])
+ if err != nil {
+ return nil, err
+ }
+ }
+ return res, nil
+}
+
+func (ec *executionContext) marshalNString2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
+ ret := make(graphql.Array, len(v))
+ for i := range v {
+ ret[i] = ec.marshalNString2string(ctx, sel, v[i])
+ }
+
+ for _, e := range ret {
+ if e == graphql.Null {
+ return graphql.Null
+ }
+ }
+
+ return ret
+}
+
+func (ec *executionContext) marshalNTable2ᚕᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐTableᚄ(ctx context.Context, sel ast.SelectionSet, v []*model1.Table) graphql.Marshaler {
+ ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler {
+ fc := graphql.GetFieldContext(ctx)
+ fc.Result = &v[i]
+ return ec.marshalNTable2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐTable(ctx, sel, v[i])
+ })
+
+ for _, e := range ret {
+ if e == graphql.Null {
+ return graphql.Null
+ }
+ }
+
+ return ret
+}
+
+func (ec *executionContext) marshalNTable2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐTable(ctx context.Context, sel ast.SelectionSet, v *model1.Table) graphql.Marshaler {
+ if v == nil {
+ if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
+ graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
+ }
+ return graphql.Null
+ }
+ return ec._Table(ctx, sel, v)
+}
+
+func (ec *executionContext) unmarshalNTime2timeᚐTime(ctx context.Context, v any) (time.Time, error) {
+ res, err := graphql.UnmarshalTime(v)
+ return res, graphql.ErrorOnPath(ctx, err)
+}
+
+func (ec *executionContext) marshalNTime2timeᚐTime(ctx context.Context, sel ast.SelectionSet, v time.Time) graphql.Marshaler {
+ _ = sel
+ res := graphql.MarshalTime(v)
+ if res == graphql.Null {
+ if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
+ graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
+ }
+ }
+ return res
+}
+
+func (ec *executionContext) marshalNUser2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐUser(ctx context.Context, sel ast.SelectionSet, v *model1.User) graphql.Marshaler {
+ if v == nil {
+ if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
+ graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
+ }
+ return graphql.Null
+ }
+ return ec._User(ctx, sel, v)
+}
+
+func (ec *executionContext) unmarshalNVisibility2sourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐVisibility(ctx context.Context, v any) (model1.Visibility, error) {
+ var res model1.Visibility
+ err := res.UnmarshalGQL(v)
+ return res, graphql.ErrorOnPath(ctx, err)
+}
+
+func (ec *executionContext) marshalNVisibility2sourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐVisibility(ctx context.Context, sel ast.SelectionSet, v model1.Visibility) graphql.Marshaler {
+ return v
+}
+
+func (ec *executionContext) marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx context.Context, sel ast.SelectionSet, v introspection.Directive) graphql.Marshaler {
+ return ec.___Directive(ctx, sel, &v)
+}
+
+func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Directive) graphql.Marshaler {
+ ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler {
+ fc := graphql.GetFieldContext(ctx)
+ fc.Result = &v[i]
+ return ec.marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, sel, v[i])
+ })
+
+ for _, e := range ret {
+ if e == graphql.Null {
+ return graphql.Null
+ }
+ }
+
+ return ret
+}
+
+func (ec *executionContext) unmarshalN__DirectiveLocation2string(ctx context.Context, v any) (string, error) {
+ res, err := graphql.UnmarshalString(v)
+ return res, graphql.ErrorOnPath(ctx, err)
+}
+
+func (ec *executionContext) marshalN__DirectiveLocation2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
+ _ = sel
+ res := graphql.MarshalString(v)
+ if res == graphql.Null {
+ if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
+ graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
+ }
+ }
+ return res
+}
+
+func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, v any) ([]string, error) {
+ vSlice := graphql.CoerceList(v)
+ var err error
+ res := make([]string, len(vSlice))
+ for i := range vSlice {
+ ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
+ res[i], err = ec.unmarshalN__DirectiveLocation2string(ctx, vSlice[i])
+ if err != nil {
+ return nil, err
+ }
+ }
+ return res, nil
+}
+
+func (ec *executionContext) marshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
+ ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler {
+ fc := graphql.GetFieldContext(ctx)
+ fc.Result = &v[i]
+ return ec.marshalN__DirectiveLocation2string(ctx, sel, v[i])
+ })
+
+ for _, e := range ret {
+ if e == graphql.Null {
+ return graphql.Null
+ }
+ }
+
+ return ret
+}
+
+func (ec *executionContext) marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx context.Context, sel ast.SelectionSet, v introspection.EnumValue) graphql.Marshaler {
+ return ec.___EnumValue(ctx, sel, &v)
+}
+
+func (ec *executionContext) marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx context.Context, sel ast.SelectionSet, v introspection.Field) graphql.Marshaler {
+ return ec.___Field(ctx, sel, &v)
+}
+
+func (ec *executionContext) marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx context.Context, sel ast.SelectionSet, v introspection.InputValue) graphql.Marshaler {
+ return ec.___InputValue(ctx, sel, &v)
+}
+
+func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
+ ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler {
+ fc := graphql.GetFieldContext(ctx)
+ fc.Result = &v[i]
+ return ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
+ })
+
+ for _, e := range ret {
+ if e == graphql.Null {
+ return graphql.Null
+ }
+ }
+
+ return ret
+}
+
+func (ec *executionContext) marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
+ return ec.___Type(ctx, sel, &v)
+}
+
+func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
+ ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler {
+ fc := graphql.GetFieldContext(ctx)
+ fc.Result = &v[i]
+ return ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
+ })
+
+ for _, e := range ret {
+ if e == graphql.Null {
+ return graphql.Null
+ }
+ }
+
+ return ret
+}
+
+func (ec *executionContext) marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
+ if v == nil {
+ if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
+ graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
+ }
+ return graphql.Null
+ }
+ return ec.___Type(ctx, sel, v)
+}
+
+func (ec *executionContext) unmarshalN__TypeKind2string(ctx context.Context, v any) (string, error) {
+ res, err := graphql.UnmarshalString(v)
+ return res, graphql.ErrorOnPath(ctx, err)
+}
+
+func (ec *executionContext) marshalN__TypeKind2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
+ _ = sel
+ res := graphql.MarshalString(v)
+ if res == graphql.Null {
+ if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
+ graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
+ }
+ }
+ return res
+}
+
+func (ec *executionContext) unmarshalOBoolean2bool(ctx context.Context, v any) (bool, error) {
+ res, err := graphql.UnmarshalBoolean(v)
+ return res, graphql.ErrorOnPath(ctx, err)
+}
+
+func (ec *executionContext) marshalOBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
+ _ = sel
+ _ = ctx
+ res := graphql.MarshalBoolean(v)
+ return res
+}
+
+func (ec *executionContext) unmarshalOBoolean2ᚖbool(ctx context.Context, v any) (*bool, error) {
+ if v == nil {
+ return nil, nil
+ }
+ res, err := graphql.UnmarshalBoolean(v)
+ return &res, graphql.ErrorOnPath(ctx, err)
+}
+
+func (ec *executionContext) marshalOBoolean2ᚖbool(ctx context.Context, sel ast.SelectionSet, v *bool) graphql.Marshaler {
+ if v == nil {
+ return graphql.Null
+ }
+ _ = sel
+ _ = ctx
+ res := graphql.MarshalBoolean(*v)
+ return res
+}
+
+func (ec *executionContext) unmarshalOCursor2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑcoreᚋmodelᚐCursor(ctx context.Context, v any) (*model.Cursor, error) {
+ if v == nil {
+ return nil, nil
+ }
+ var res = new(model.Cursor)
+ err := res.UnmarshalGQL(v)
+ return res, graphql.ErrorOnPath(ctx, err)
+}
+
+func (ec *executionContext) marshalOCursor2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑcoreᚋmodelᚐCursor(ctx context.Context, sel ast.SelectionSet, v *model.Cursor) graphql.Marshaler {
+ if v == nil {
+ return graphql.Null
+ }
+ return v
+}
+
+func (ec *executionContext) marshalODatabase2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐDatabase(ctx context.Context, sel ast.SelectionSet, v *model1.Database) graphql.Marshaler {
+ if v == nil {
+ return graphql.Null
+ }
+ return ec._Database(ctx, sel, v)
+}
+
+func (ec *executionContext) unmarshalOFilter2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑcoreᚋmodelᚐFilter(ctx context.Context, v any) (*model.Filter, error) {
+ if v == nil {
+ return nil, nil
+ }
+ res, err := ec.unmarshalInputFilter(ctx, v)
+ return &res, graphql.ErrorOnPath(ctx, err)
+}
+
+func (ec *executionContext) unmarshalOInt2ᚖint(ctx context.Context, v any) (*int, error) {
+ if v == nil {
+ return nil, nil
+ }
+ res, err := graphql.UnmarshalInt(v)
+ return &res, graphql.ErrorOnPath(ctx, err)
+}
+
+func (ec *executionContext) marshalOInt2ᚖint(ctx context.Context, sel ast.SelectionSet, v *int) graphql.Marshaler {
+ if v == nil {
+ return graphql.Null
+ }
+ _ = sel
+ _ = ctx
+ res := graphql.MarshalInt(*v)
+ return res
+}
+
+func (ec *executionContext) unmarshalOString2ᚖstring(ctx context.Context, v any) (*string, error) {
+ if v == nil {
+ return nil, nil
+ }
+ res, err := graphql.UnmarshalString(v)
+ return &res, graphql.ErrorOnPath(ctx, err)
+}
+
+func (ec *executionContext) marshalOString2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
+ if v == nil {
+ return graphql.Null
+ }
+ _ = sel
+ _ = ctx
+ res := graphql.MarshalString(*v)
+ return res
+}
+
+func (ec *executionContext) marshalOUser2ᚖsourcecraftᚗdevᚋbigbesᚋsrᚑhtᚑdoltᚋgraphᚋmodelᚐUser(ctx context.Context, sel ast.SelectionSet, v *model1.User) graphql.Marshaler {
+ if v == nil {
+ return graphql.Null
+ }
+ return ec._User(ctx, sel, v)
+}
+
+func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.EnumValue) graphql.Marshaler {
+ if v == nil {
+ return graphql.Null
+ }
+ ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler {
+ fc := graphql.GetFieldContext(ctx)
+ fc.Result = &v[i]
+ return ec.marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, sel, v[i])
+ })
+
+ for _, e := range ret {
+ if e == graphql.Null {
+ return graphql.Null
+ }
+ }
+
+ return ret
+}
+
+func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Field) graphql.Marshaler {
+ if v == nil {
+ return graphql.Null
+ }
+ ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler {
+ fc := graphql.GetFieldContext(ctx)
+ fc.Result = &v[i]
+ return ec.marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, sel, v[i])
+ })
+
+ for _, e := range ret {
+ if e == graphql.Null {
+ return graphql.Null
+ }
+ }
+
+ return ret
+}
+
+func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
+ if v == nil {
+ return graphql.Null
+ }
+ ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler {
+ fc := graphql.GetFieldContext(ctx)
+ fc.Result = &v[i]
+ return ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
+ })
+
+ for _, e := range ret {
+ if e == graphql.Null {
+ return graphql.Null
+ }
+ }
+
+ return ret
+}
+
+func (ec *executionContext) marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v *introspection.Schema) graphql.Marshaler {
+ if v == nil {
+ return graphql.Null
+ }
+ return ec.___Schema(ctx, sel, v)
+}
+
+func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
+ if v == nil {
+ return graphql.Null
+ }
+ ret := graphql.MarshalSliceConcurrently(ctx, len(v), 0, false, func(ctx context.Context, i int) graphql.Marshaler {
+ fc := graphql.GetFieldContext(ctx)
+ fc.Result = &v[i]
+ return ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
+ })
+
+ for _, e := range ret {
+ if e == graphql.Null {
+ return graphql.Null
+ }
+ }
+
+ return ret
+}
+
+func (ec *executionContext) marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
+ if v == nil {
+ return graphql.Null
+ }
+ return ec.___Type(ctx, sel, v)
+}
+
+// endregion ***************************** type.gotpl *****************************