graphql-jit 0.8.9 → 0.9.0

package/dist/cjs/execution.d.ts

@@ -0,0 +1,154 @@
+import { type TypedDocumentNode } from "@graphql-typed-document-node/core";
+import { type JitRuntime } from "./runtime.js";
+import { type CompilerDebugOptions } from "./debug.js";
+import { type DocumentNode, type ExecutionResult, type FragmentDefinitionNode, GraphQLError, type GraphQLFieldResolver, type GraphQLIsTypeOfFn, GraphQLObjectType, type GraphQLOutputType, GraphQLSchema, type FieldNode, type OperationDefinitionNode, type GraphQLTypeResolver } from "graphql";
+import { type ExecutionContext as GraphQLContext } from "./compat.js";
+import { type Arguments, type ObjectPath } from "./ast.js";
+import { GraphQLError as GraphqlJitError } from "./error.js";
+import { type NullTrimmer } from "./non-null.js";
+import { type ResolveInfoEnricherInput } from "./resolve-info.js";
+import { type Maybe } from "./types.js";
+import { type CoercedVariableValues } from "./variables.js";
+declare const inspect: (value: any) => string;
+export interface CompilerOptions {
+    customJSONSerializer: boolean;
+    disableLeafSerialization: boolean;
+    disablingCapturingStackErrors: boolean;
+    customSerializers: {
+        [key: string]: (v: any) => any;
+    };
+    resolverInfoEnricher?: (inp: ResolveInfoEnricherInput) => object;
+    /**
+     * This option is a temporary workaround to rollout and test the new skip/include behavior.
+     * It will be removed in the next version along with the old behavior.
+     *
+     * Set this to true if you face issues with skip/include in fragment spreads.
+     *
+     * default: false
+     *
+     * @see https://github.com/zalando-incubator/graphql-jit/pull/197
+     *
+     */
+    useExperimentalPathBasedSkipInclude: boolean;
+    /** Expose generated executors to JavaScript debuggers with virtual names. */
+    debug?: CompilerDebugOptions;
+}
+export interface ExecutionContext {
+    promiseCounter: number;
+    data: any;
+    errors: GraphQLError[];
+    nullErrors: GraphQLError[];
+    resolve?: (ctx: ExecutionContext) => void;
+    rt: JitRuntime;
+    inspect: typeof inspect;
+    variables: {
+        [key: string]: any;
+    };
+    context: any;
+    rootValue: any;
+    GraphQLError: typeof GraphqlJitError;
+    resolvers: {
+        [key: string]: GraphQLFieldResolver<any, any, any>;
+    };
+    trimmer: NullTrimmer;
+    serializers: {
+        [key: string]: (c: ExecutionContext, v: any, onError: (c: ExecutionContext, msg: string) => void) => any;
+    };
+    typeResolvers: {
+        [key: string]: GraphQLTypeResolver<any, any>;
+    };
+    isTypeOfs: {
+        [key: string]: GraphQLIsTypeOfFn<any, any>;
+    };
+    resolveInfos: {
+        [key: string]: any;
+    };
+}
+interface DeferredField {
+    name: string;
+    responsePath: ObjectPath;
+    originPaths: string[];
+    originPathsFormatted: string;
+    destinationPaths: string[];
+    parentType: GraphQLObjectType;
+    fieldName: string;
+    jsFieldName: string;
+    fieldType: GraphQLOutputType;
+    fieldNodes: FieldNode[];
+    args: Arguments;
+}
+/**
+ * The context used during compilation.
+ *
+ * It stores deferred nodes to be processed later as well as the function arguments to be bounded at top level
+ */
+export interface CompilationContext extends GraphQLContext {
+    resolvers: {
+        [key: string]: GraphQLFieldResolver<any, any, any>;
+    };
+    serializers: {
+        [key: string]: (c: ExecutionContext, v: any, onError: (c: ExecutionContext, msg: string) => void) => any;
+    };
+    hoistedFunctions: string[];
+    hoistedFunctionNames: Map<string, number>;
+    leafErrHandlerCache: Map<string, string>;
+    trivialTypeNameVar?: string;
+    typeResolvers: {
+        [key: string]: GraphQLTypeResolver<any, any>;
+    };
+    isTypeOfs: {
+        [key: string]: GraphQLIsTypeOfFn<any, any>;
+    };
+    resolveInfos: {
+        [key: string]: any;
+    };
+    deferred: DeferredField[];
+    options: CompilerOptions;
+    depth: number;
+    schema: GraphQLSchema;
+    operation: OperationDefinitionNode;
+    fragments: {
+        [key: string]: FragmentDefinitionNode;
+    };
+}
+export declare const GLOBAL_VARIABLES_NAME = "__context.variables";
+export interface CompiledQuery<TResult = {
+    [key: string]: any;
+}, TVariables = {
+    [key: string]: any;
+}> {
+    operationName?: string;
+    query: (root: any, context: any, variables: Maybe<TVariables>) => Promise<ExecutionResult<TResult>> | ExecutionResult<TResult>;
+    subscribe?: (root: any, context: any, variables: Maybe<TVariables>) => Promise<AsyncIterableIterator<ExecutionResult<TResult>> | ExecutionResult<TResult>>;
+    stringify: (v: any) => string;
+}
+/**
+ * It compiles a GraphQL query to an executable function
+ * @param {GraphQLSchema} schema GraphQL schema
+ * @param {DocumentNode} document Query being submitted
+ * @param {string} operationName name of the operation
+ * @param partialOptions compilation options to tune the compiler features
+ * @returns {CompiledQuery} the cacheable result
+ */
+export declare function compileQuery<TResult = {
+    [key: string]: any;
+}, TVariables = {
+    [key: string]: any;
+}>(schema: GraphQLSchema, document: TypedDocumentNode<TResult, TVariables>, operationName?: string, partialOptions?: Partial<CompilerOptions>): CompiledQuery<TResult, TVariables> | ExecutionResult<TResult>;
+export declare function isCompiledQuery<C extends CompiledQuery, E extends ExecutionResult>(query: C | E): query is C;
+export declare function createBoundQuery(compilationContext: CompilationContext, document: DocumentNode, func: (context: ExecutionContext) => Promise<any> | undefined, getVariableValues: (inputs: {
+    [key: string]: any;
+}) => CoercedVariableValues, operationName?: string): (rootValue: any, context: any, variables: Maybe<{
+    [key: string]: any;
+}>) => Promise<ExecutionResult> | ExecutionResult;
+export declare function isPromise(value: any): value is Promise<any>;
+export declare function isPromiseInliner(value: string): string;
+/**
+ * Constructs a ExecutionContext object from the arguments passed to
+ * execute, which we will pass throughout the other execution methods.
+ *
+ * Throws a GraphQLError if a valid execution context cannot be created.
+ */
+export declare function buildCompilationContext(schema: GraphQLSchema, document: DocumentNode, options: CompilerOptions, operationName?: string): CompilationContext;
+export declare function isAsyncIterable<T = unknown>(val: unknown): val is AsyncIterableIterator<T>;
+export {};