@backland/schema/lib/createGraphQLSchema.d.ts

TypeScript schema declaration and validation library with static type inference

import type { GraphQLSchemaConfig } from 'graphql';
import { SchemaQueryTemplatesResult } from './GraphType/getQueryTemplates';
import { AnyResolver } from './Resolver';
import { ObjectMockOptions } from './mockObject';
import type { ObjectToTypescriptOptions } from './objectToTypescript';
export type CreateGraphQLObjectOptions = Partial<GraphQLSchemaConfig>;
export type GroupedResolvers = {
    [K in AnyResolver['kind']]: undefined | AnyResolver[];
};
export type GraphQLSchemaWithUtils = import('graphql').GraphQLSchema & {
    utils: {
        generateClientUtils: () => Promise<string>;
        grouped: GroupedResolvers;
        print: () => string;
        queryExamples: (options?: ObjectMockOptions & {
            resolver?: string;
        }) => string;
        queryTemplates: () => SchemaQueryTemplatesResult;
        registeredResolvers: AnyResolver[];
        resolvers: AnyResolver[];
        typescript: (options?: ResolversToTypeScriptOptions) => Promise<string>;
        usedConfig: GraphQLSchemaConfig;
    };
};
export declare const resolverKinds: {
    readonly query: "query";
    readonly mutation: "mutation";
    readonly subscription: "subscription";
} & {
    list: ("query" | "mutation" | "subscription")[];
} & {
    enum: "query" | "mutation" | "subscription";
};
export type ResolverKind = typeof resolverKinds.enum;
export declare function createGraphQLSchema<T = any>(resolvers?: T[], config?: CreateGraphQLObjectOptions): T extends {
    __isResolver: any;
} ? GraphQLSchemaWithUtils : never;
export declare function createGraphQLSchema<Config>(config?: Config): Config extends CreateGraphQLObjectOptions ? GraphQLSchemaWithUtils : never;
export type ResolversToTypeScriptOptions = {
    name: string;
    options?: ObjectToTypescriptOptions;
    resolvers: AnyResolver[];
};
export declare function resolversTypescriptParts(params: ResolversToTypeScriptOptions): Promise<{
    code: string;
    lines: {
        args: {
            code: any;
            comments: string;
            description: string;
        };
        code: string;
        entryName: string;
        inputName: any;
        payload: {
            code: any;
            comments: string;
            description: string;
        };
        payloadName: any;
        resolver: {
            description?: import("graphql/jsutils/Maybe").Maybe<string>;
            subscribe?: import("graphql").GraphQLFieldResolver<any, any, any, unknown> | undefined;
            deprecationReason?: import("graphql/jsutils/Maybe").Maybe<string>;
            extensions?: import("graphql/jsutils/Maybe").Maybe<Readonly<import("graphql").GraphQLFieldExtensions<any, any, any>>>;
            astNode?: import("graphql/jsutils/Maybe").Maybe<import("graphql").FieldDefinitionNode>;
            __graphTypeId: string;
            __isRelation: boolean;
            __isResolver: true;
            __relatedToGraphTypeId: string;
            args: any;
            argsDef: any;
            argsType: any;
            asObjectField: (name?: string | undefined) => import("graphql").GraphQLField<any, any, any>;
            kind: import("./Resolver").ResolverKind;
            name: string;
            payloadType: any;
            type: any;
            typeDef: any;
            resolve: <Root>(root: Root, args: any, context: any, info: import("graphql").GraphQLResolveInfo) => any;
        };
    }[];
}>;
export declare function resolversToTypescript(params: ResolversToTypeScriptOptions): Promise<any>;