grafast 0.1.1-beta.0 → 0.1.1-beta.2

package/dist/grafastPrint.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ansiPad = exports.grafastPrint = exports.grafastColor = exports._grafastPrint = void 0;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const inspect_js_1 = require("./inspect.js");
+const step_js_1 = require("./step.js");
+const stripAnsi_js_1 = require("./stripAnsi.js");
+const utils_js_1 = require("./utils.js");
+/*
+ * This file contains utilities used with the `debug` module primarily (but
+ * also used elsewhere) that are useful for outputting Grafast stuff in a
+ * more helpful way - typically with more relevant detail and colours to help
+ * you (me) digest things.
+ */
+const COLORS = [
+    //chalk.black,
+    chalk_1.default.yellow,
+    chalk_1.default.magenta,
+    //chalk.cyan,
+    chalk_1.default.red,
+    //chalk.white,
+    //chalk.blackBright,
+    chalk_1.default.greenBright,
+    chalk_1.default.yellowBright,
+    chalk_1.default.blueBright,
+    chalk_1.default.magentaBright,
+    chalk_1.default.cyanBright,
+    chalk_1.default.redBright,
+    chalk_1.default.blue,
+    chalk_1.default.green,
+    //chalk.whiteBright,
+];
+const BG_COLORS = [
+    // chalk.bgRgb(53, 0, 0),
+    // chalk.bgRgb(0, 53, 0),
+    // chalk.bgRgb(0, 0, 53),
+    chalk_1.default.visible,
+    chalk_1.default.underline,
+];
+function _grafastPrint(symbol, seen) {
+    if ((0, utils_js_1.isDeferred)(symbol)) {
+        return chalk_1.default.gray `<Deferred>`;
+    }
+    if ((0, utils_js_1.isPromise)(symbol)) {
+        return chalk_1.default.gray `<Promise>`;
+    }
+    if (symbol === utils_js_1.ROOT_VALUE_OBJECT) {
+        return chalk_1.default.gray `(blank)`;
+    }
+    if (symbol instanceof step_js_1.ExecutableStep) {
+        return String(symbol);
+    }
+    if (Array.isArray(symbol)) {
+        if (seen.has(symbol)) {
+            return chalk_1.default.gray `(loop)`;
+        }
+        seen.add(symbol);
+        return `[${symbol
+            .map((value, i) => BG_COLORS[i % BG_COLORS.length](_grafastPrint(value, new Set(seen))))
+            .join(", ")}]`;
+    }
+    if (symbol instanceof Map) {
+        if (seen.has(symbol)) {
+            return chalk_1.default.gray `(loop)`;
+        }
+        seen.add(symbol);
+        const pairs = [];
+        let i = 0;
+        for (const [key, value] of symbol.entries()) {
+            pairs.push(BG_COLORS[i % BG_COLORS.length](`${_grafastPrint(key, new Set(seen))}: ${_grafastPrint(value, new Set(seen))}`));
+            i++;
+        }
+        return `Map{${pairs.join(", ")}}`;
+    }
+    if (typeof symbol === "object" && symbol) {
+        if (symbol instanceof Error) {
+            return chalk_1.default.red(`ERROR<${(0, stripAnsi_js_1.stripAnsi)(String(symbol.message))
+                .replace(/\s+/g, " ")
+                .substring(0, 30) + "..."}>`);
+        }
+        if (![null, Object.prototype, utils_js_1.sharedNull].includes(Object.getPrototypeOf(symbol))) {
+            return chalk_1.default.red(`OBJECT<${(0, stripAnsi_js_1.stripAnsi)(String(symbol))}>`);
+        }
+        if (seen.has(symbol)) {
+            return chalk_1.default.gray `(loop)`;
+        }
+        seen.add(symbol);
+        return `{${[...Object.keys(symbol), ...Object.getOwnPropertySymbols(symbol)]
+            .map((key, i) => BG_COLORS[i % BG_COLORS.length](`${_grafastPrint(key, new Set(seen))}: ${_grafastPrint(symbol[key], new Set(seen))}`))
+            .join(", ")}}`;
+    }
+    if (typeof symbol !== "symbol") {
+        return (0, inspect_js_1.inspect)(symbol, { colors: true });
+    }
+    return grafastPrintSymbol(symbol);
+}
+exports._grafastPrint = _grafastPrint;
+function _grafastSymbolDescription(symbol) {
+    if (!symbol.description) {
+        return chalk_1.default.green("Symbol()");
+    }
+    const nStr = symbol.description?.replace(/[^0-9]/g, "") || "";
+    const n = parseInt(nStr, 10) || 0;
+    if (n > 0) {
+        return grafastColor(symbol.description, n);
+    }
+    else {
+        return chalk_1.default.cyan(`$$${symbol.description}`);
+    }
+}
+function grafastColor(text, n) {
+    const color = COLORS[Math.abs(n) % COLORS.length];
+    return color(text);
+}
+exports.grafastColor = grafastColor;
+const symbolsByAlias = new Map();
+let symbolClear = null;
+/**
+ * Returns a text description for a symbol that helps differentiate similar
+ * symbols by keeping track of the symbols/descriptions it has seen and adding
+ * numeric identifiers to the output. Only tracks symbols over a short period
+ * so counts will reset very frequently.
+ */
+function grafastPrintSymbol(symbol) {
+    const description = _grafastSymbolDescription(symbol);
+    if (!symbolClear) {
+        // Only cache symbols for a few milliseconds, we don't want a memory leak!
+        symbolClear = setTimeout(() => {
+            symbolClear = null;
+            symbolsByAlias.clear();
+        }, 200);
+    }
+    const symbols = symbolsByAlias.get(description);
+    if (!symbols) {
+        symbolsByAlias.set(description, [symbol]);
+        return description;
+    }
+    let idx = symbols.indexOf(symbol);
+    if (idx === 0) {
+        return description;
+    }
+    if (idx < 0) {
+        idx = symbols.push(symbol) - 1;
+    }
+    return `${description}${chalk_1.default.gray(`:${idx + 1}`)}`;
+}
+/**
+ * Prints something grafast-style (i.e. concise, coloured, with helpful detail)
+ */
+function grafastPrint(symbol) {
+    return _grafastPrint(symbol, new Set());
+}
+exports.grafastPrint = grafastPrint;
+/**
+ * An ANSI-aware pad function; strips ANSI sequences from the string, figures
+ * out how much it needs to pad it by, and then pads the original string by
+ * that amount.
+ */
+function ansiPad(ansiString, targetLength, fill, position) {
+    const string = (0, stripAnsi_js_1.stripAnsi)(ansiString);
+    const fillLength = targetLength - string.length;
+    if (fillLength >= 0) {
+        const fillString = fill.repeat(fillLength);
+        if (position === "start") {
+            return fillString + ansiString;
+        }
+        else {
+            return ansiString + fillString;
+        }
+    }
+    else {
+        return ansiString;
+    }
+}
+exports.ansiPad = ansiPad;
+//# sourceMappingURL=grafastPrint.js.map

package/dist/graphqlCollectFields.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.graphqlCollectFields = exports.evalDirectiveArgDirect = exports.evalDirectiveArg = void 0;
+const tslib_1 = require("tslib");
+const graphql = tslib_1.__importStar(require("graphql"));
+const error_js_1 = require("./error.js");
+const { GraphQLError, GraphQLInterfaceType, GraphQLObjectType, GraphQLUnionType, } = graphql;
+/**
+ * Given a selection, finds the first directive named `directiveName`.
+ *
+ * @internal
+ *
+ * PERF: inline.
+ */
+function getDirective(selection, directiveName) {
+    return selection.directives?.find((d) => d.name.value === directiveName);
+}
+/**
+ * Given a selection, finds the first directive named `directiveName` and, if
+ * found, extracts and returns the value from the argument named
+ * `argumentName`, tracking variable access if necessary.
+ *
+ * @remarks Currently only supports booleans.
+ *
+ * @internal
+ *
+ * PERF: inline.
+ */
+function evalDirectiveArg(selection, directiveName, argumentName, variableValuesStep, defaultValue) {
+    const directive = getDirective(selection, directiveName);
+    if (!directive)
+        return undefined;
+    return evalDirectiveArgDirect(directive, argumentName, variableValuesStep, defaultValue);
+}
+exports.evalDirectiveArg = evalDirectiveArg;
+function evalDirectiveArgDirect(directive, argumentName, variableValuesStep, defaultValue) {
+    if (!directive.arguments)
+        return defaultValue;
+    const argument = directive.arguments.find((a) => a.name.value === argumentName);
+    if (argument !== undefined) {
+        const value = argument.value;
+        switch (value.kind) {
+            case "Variable": {
+                return variableValuesStep.get(value.name.value).eval();
+            }
+            case "BooleanValue": {
+                return value.value;
+            }
+            case "IntValue": {
+                return parseInt(value.value, 10);
+            }
+            case "NullValue": {
+                return null;
+            }
+            default: {
+                throw new error_js_1.SafeError(`Unsupported @${directive.name}(${argumentName}:) argument; expected Variable, Boolean or null; but received '${value.kind}'`);
+            }
+        }
+    }
+    else {
+        return defaultValue;
+    }
+}
+exports.evalDirectiveArgDirect = evalDirectiveArgDirect;
+/**
+ * Implements the `DoesFragmentTypeApply` algorithm from the GraphQL
+ * specification.
+ *
+ * @see https://spec.graphql.org/draft/#DoesFragmentTypeApply()
+ *
+ * @internal
+ */
+function graphqlDoesFragmentTypeApply(objectType, fragmentType) {
+    if (fragmentType instanceof GraphQLObjectType) {
+        return objectType === fragmentType;
+    }
+    else if (fragmentType instanceof GraphQLInterfaceType) {
+        const interfaces = objectType.getInterfaces();
+        return interfaces.includes(fragmentType);
+    }
+    else if (fragmentType instanceof GraphQLUnionType) {
+        const types = fragmentType.getTypes();
+        return types.includes(objectType);
+    }
+    else {
+        throw new Error("Invalid call to graphqlDoesFragmentTypeApply");
+    }
+}
+const processFragment = (operationPlan, parentStepId, objectType, isMutation, selectionSetDigest, selection, fragmentSelectionSet, visitedFragments) => {
+    const trackedVariableValuesStep = operationPlan.trackedVariableValuesStep;
+    const defer = selection.directives?.find((d) => d.name.value === "defer");
+    const deferIf = defer
+        ? evalDirectiveArgDirect(defer, "if", trackedVariableValuesStep, true) ?? true
+        : undefined;
+    const label = defer
+        ? evalDirectiveArgDirect(defer, "label", trackedVariableValuesStep, null) ?? undefined
+        : undefined;
+    const deferredDigest = deferIf === true
+        ? {
+            label,
+            fields: new Map(),
+            deferred: undefined,
+        }
+        : null;
+    if (deferredDigest !== null) {
+        if (selectionSetDigest.deferred === undefined) {
+            selectionSetDigest.deferred = [deferredDigest];
+        }
+        else {
+            selectionSetDigest.deferred.push(deferredDigest);
+        }
+    }
+    graphqlCollectFields(operationPlan, parentStepId, objectType, fragmentSelectionSet.selections, isMutation, visitedFragments, deferredDigest ?? selectionSetDigest);
+};
+/**
+ * Implements the `GraphQLCollectFields` algorithm - like `CollectFields` the
+ * GraphQL spec, but modified such that access to variables is tracked.
+ *
+ * @see https://spec.graphql.org/draft/#CollectFields()
+ *
+ * @internal
+ */
+function graphqlCollectFields(operationPlan, parentStepId, objectType, selections, isMutation = false, 
+// This is significantly faster than an array or a Set
+visitedFragments = Object.create(null), selectionSetDigest = {
+    label: undefined,
+    fields: new Map(),
+    deferred: undefined,
+}) {
+    // const objectTypeFields = objectType.getFields();
+    const trackedVariableValuesStep = operationPlan.trackedVariableValuesStep;
+    for (let i = 0, l = selections.length; i < l; i++) {
+        const selection = selections[i];
+        if (selection.directives !== undefined) {
+            if (evalDirectiveArg(selection, "skip", "if", trackedVariableValuesStep, true) === true) {
+                continue;
+            }
+            if (evalDirectiveArg(selection, "include", "if", trackedVariableValuesStep, true) === false) {
+                continue;
+            }
+        }
+        switch (selection.kind) {
+            case "Field": {
+                const field = selection;
+                const responseKey = field.alias ? field.alias.value : field.name.value;
+                let groupForResponseKey = selectionSetDigest.fields.get(responseKey);
+                if (groupForResponseKey === undefined) {
+                    groupForResponseKey = [field];
+                    selectionSetDigest.fields.set(responseKey, groupForResponseKey);
+                }
+                else {
+                    groupForResponseKey.push(field);
+                }
+                break;
+            }
+            case "FragmentSpread": {
+                const fragmentSpreadName = selection.name.value;
+                if (visitedFragments[fragmentSpreadName]) {
+                    continue;
+                }
+                const fragment = operationPlan.fragments[fragmentSpreadName];
+                // This is forbidden by validation
+                if (fragment == null)
+                    continue;
+                const fragmentTypeName = fragment.typeCondition.name.value;
+                if (fragmentTypeName === objectType.name) {
+                    // No further checks needed
+                }
+                else {
+                    const fragmentType = operationPlan.schema.getType(fragmentTypeName);
+                    // This is forbidden by validation
+                    if (!fragmentType)
+                        continue;
+                    if (fragmentType.constructor === GraphQLObjectType ||
+                        /* According to validation, this must be the case */
+                        // !(isInterfaceType(fragmentType) || isUnionType(fragmentType)) ||
+                        !graphqlDoesFragmentTypeApply(objectType, fragmentType)) {
+                        continue;
+                    }
+                }
+                const fragmentSelectionSet = fragment.selectionSet;
+                const newVisitedFragments = Object.assign(Object.create(null), visitedFragments);
+                newVisitedFragments[fragmentSpreadName] = true;
+                processFragment(operationPlan, parentStepId, objectType, isMutation, selectionSetDigest, selection, fragmentSelectionSet, newVisitedFragments);
+                break;
+            }
+            case "InlineFragment": {
+                const fragmentTypeAst = selection.typeCondition;
+                if (fragmentTypeAst != null) {
+                    const fragmentTypeName = fragmentTypeAst.name.value;
+                    if (fragmentTypeName === objectType.name) {
+                        // No further checks required
+                    }
+                    else {
+                        const fragmentType = operationPlan.schema.getType(fragmentTypeName);
+                        // This is forbidden by validation
+                        if (fragmentType == null) {
+                            throw new GraphQLError(`We don't have a type named '${fragmentTypeName}'`);
+                        }
+                        if (fragmentType.constructor === GraphQLObjectType ||
+                            /* According to validation, this must be the case */
+                            // !(isInterfaceType(fragmentType) || isUnionType(fragmentType)) ||
+                            !graphqlDoesFragmentTypeApply(objectType, fragmentType)) {
+                            continue;
+                        }
+                    }
+                }
+                const fragmentSelectionSet = selection.selectionSet;
+                processFragment(operationPlan, parentStepId, objectType, isMutation, selectionSetDigest, selection, fragmentSelectionSet, visitedFragments);
+                break;
+            }
+        }
+    }
+    return selectionSetDigest;
+}
+exports.graphqlCollectFields = graphqlCollectFields;
+//# sourceMappingURL=graphqlCollectFields.js.map

package/dist/graphqlMergeSelectionSets.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fieldSelectionsForType = void 0;
+const tslib_1 = require("tslib");
+const graphql = tslib_1.__importStar(require("graphql"));
+const inspect_js_1 = require("./inspect.js");
+const { Kind } = graphql;
+// PERF: this is incredibly inefficient
+function typeMatchesCondition(operationPlan, type, condition) {
+    const name = condition.name.value;
+    if (type.name === name) {
+        return true;
+    }
+    if (type.getInterfaces().some((i) => i.name === name)) {
+        return true;
+    }
+    if (operationPlan.unionsContainingObjectType[type.name].some((u) => u.name === name)) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Given a list of polymorphic selections, return a list of the nested field
+ * selections that apply to the object type `type`.
+ */
+function fieldSelectionsForType(operationPlan, type, selections, result = []) {
+    for (let i = 0, l = selections.length; i < l; i++) {
+        const selection = selections[i];
+        switch (selection.kind) {
+            case Kind.FRAGMENT_SPREAD: {
+                // Assumed to exist because query passed validation.
+                const fragment = operationPlan.fragments[selection.name.value];
+                const typeCondition = fragment.typeCondition;
+                if (typeMatchesCondition(operationPlan, type, typeCondition)) {
+                    fieldSelectionsForType(operationPlan, type, fragment.selectionSet.selections, result);
+                }
+                break;
+            }
+            case Kind.INLINE_FRAGMENT: {
+                const typeCondition = selection.typeCondition;
+                if (!typeCondition ||
+                    typeMatchesCondition(operationPlan, type, typeCondition)) {
+                    fieldSelectionsForType(operationPlan, type, selection.selectionSet.selections, result);
+                }
+                break;
+            }
+            case Kind.FIELD: {
+                result.push(selection);
+                break;
+            }
+            default: {
+                const never = selection;
+                throw new Error(`GrafastInternalError<10b01e35-cf2b-4f48-9c66-486cdef00323>: cannot process selection '${(0, inspect_js_1.inspect)(never)}'`);
+            }
+        }
+    }
+    return result;
+}
+exports.fieldSelectionsForType = fieldSelectionsForType;
+//# sourceMappingURL=graphqlMergeSelectionSets.js.map

package/dist/index.d.ts

@@ -1,4 +1,8 @@
 import "./thereCanBeOnlyOne.js";
+import type LRU from "@graphile/lru";
+import type { PluginHook } from "graphile-config";
+import type { DocumentNode, ExecutionArgs as GraphQLExecutionArgs, GraphQLError, OperationDefinitionNode } from "graphql";
+type PromiseOrValue<T> = T | Promise<T>;
 import { exportAs, exportAsMany } from "./exportAs.js";
 import { grafastPrint } from "./grafastPrint.js";
 import { EnumPlans, FieldPlans, GrafastPlans, InputObjectPlans, InterfaceOrUnionPlans, makeGrafastSchema, ObjectPlans, ScalarPlans } from "./makeGrafastSchema.js";
@@ -8,7 +12,8 @@ import { OperationPlan } from "./engine/OperationPlan.js";
 import { GrafastError, isGrafastError, isSafeError, SafeError } from "./error.js";
 import { execute } from "./execute.js";
 import { grafast, grafastSync } from "./grafastGraphql.js";
-import { $$bypassGraphQL, $$eventEmitter, $$extensions, $$idempotent, $$verbatim, ArgumentApplyPlanResolver, ArgumentInputPlanResolver, BaseEventMap, BaseGraphQLArguments, BaseGraphQLRootValue, BaseGraphQLVariables, EnumValueApplyPlanResolver, EventCallback, EventMapKey, ExecutionEventEmitter, ExecutionEventMap, ExecutionExtra, FieldArgs, FieldInfo, FieldPlanResolver, GrafastArgumentConfig, GrafastFieldConfig, GrafastFieldConfigArgumentMap, GrafastInputFieldConfig, GrafastPlanJSON, GrafastResultsList, GrafastResultStreamList, GrafastSubscriber, GrafastValuesList, InputObjectFieldApplyPlanResolver, InputObjectFieldInputPlanResolver, InputObjectTypeInputPlanResolver, InputStep, JSONArray, JSONObject, JSONValue, NodeIdCodec, NodeIdHandler, OutputPlanForType, PolymorphicData, PromiseOrDirect, ScalarPlanResolver, StepOptimizeOptions, StepStreamOptions, TypedEventEmitter } from "./interfaces.js";
+import type { $$cacheByOperation, $$hooked, $$queryCache, CacheByOperationEntry, GrafastTimeouts, ScalarInputPlanResolver } from "./interfaces.js";
+import { $$bypassGraphQL, $$eventEmitter, $$extensions, $$idempotent, $$verbatim, ArgumentApplyPlanResolver, ArgumentInputPlanResolver, BaseEventMap, BaseGraphQLArguments, BaseGraphQLRootValue, BaseGraphQLVariables, EnumValueApplyPlanResolver, EventCallback, EventMapKey, ExecutionEventEmitter, ExecutionEventMap, ExecutionExtra, FieldArgs, FieldInfo, FieldPlanResolver, GrafastArgumentConfig, GrafastFieldConfig, GrafastFieldConfigArgumentMap, GrafastInputFieldConfig, GrafastPlanJSON, GrafastResultsList, GrafastResultStreamList, GrafastSubscriber, GrafastValuesList, InputObjectFieldApplyPlanResolver, InputObjectFieldInputPlanResolver, InputObjectTypeInputPlanResolver, InputStep, JSONArray, JSONObject, JSONValue, Maybe, NodeIdCodec, NodeIdHandler, OutputPlanForType, PolymorphicData, PromiseOrDirect, ScalarPlanResolver, StepOptimizeOptions, StepStreamOptions, TypedEventEmitter } from "./interfaces.js";
 import { polymorphicWrap } from "./polymorphic.js";
 import { assertExecutableStep, assertListCapableStep, assertModifierStep, BaseStep, ExecutableStep, isExecutableStep, isListCapableStep, isListLikeStep, isModifierStep, isObjectLikeStep, isStreamableStep, ListCapableStep, ListLikeStep, ModifierStep, ObjectLikeStep, PolymorphicStep, StreamableStep, UnbatchedExecutableStep } from "./step.js";
 import { __InputListStep, __InputObjectStep, __InputObjectStepWithDollars, __InputStaticLeafStep, __ItemStep, __ListTransformStep, __TrackedValueStep, __TrackedValueStepWithDollars, __ValueStep, access, AccessStep, ActualKeyByDesiredKey, applyTransforms, ApplyTransformsStep, assertEdgeCapableStep, assertPageInfoCapableStep, connection, ConnectionCapableStep, ConnectionStep, constant, ConstantStep, context, debugPlans, each, EdgeCapableStep, EdgeStep, error, ErrorStep, filter, FilterPlanMemo, first, FirstStep, GraphQLItemHandler, graphqlItemHandler, graphqlResolver, GraphQLResolverStep, groupBy, GroupByPlanMemo, lambda, LambdaStep, last, LastStep, list, listen, ListenStep, ListStep, listTransform, ListTransformItemPlanCallback, ListTransformOptions, ListTransformReduce, LoadedRecordStep, loadMany, LoadManyCallback, loadManyCallback, loadOne, LoadOneCallback, loadOneCallback, LoadOptions, LoadStep, makeDecodeNodeId, node, NodeStep, object, ObjectPlanMeta, ObjectStep, operationPlan, PageInfoCapableStep, partitionByIndex, proxy, ProxyStep, remapKeys, RemapKeysStep, reverse, reverseArray, ReverseStep, setter, SetterCapableStep, SetterStep, specFromNodeId } from "./steps/index.js";
@@ -17,11 +22,165 @@ import { stripAnsi } from "./stripAnsi.js";
 import { subscribe } from "./subscribe.js";
 import { arrayOfLength, arraysMatch, getEnumValueConfig, GrafastInputFieldConfigMap, GrafastInputObjectType, GrafastObjectType, inputObjectFieldSpec, InputObjectTypeSpec, isPromiseLike, newGrafastFieldConfigBuilder, newInputObjectTypeBuilder, newObjectTypeBuilder, objectFieldSpec, objectSpec, ObjectTypeFields, ObjectTypeSpec, stepADependsOnStepB, stepAMayDependOnStepB, stepsAreInSamePhase } from "./utils.js";
 export { isAsyncIterable } from "iterall";
-export { __InputListStep, __InputObjectStep, __InputObjectStepWithDollars, __InputStaticLeafStep, __ItemStep, __ListTransformStep, __TrackedValueStep, __TrackedValueStepWithDollars, __ValueStep, $$bypassGraphQL, $$eventEmitter, $$extensions, $$idempotent, $$verbatim, access, AccessStep, ActualKeyByDesiredKey, applyTransforms, ApplyTransformsStep, ArgumentApplyPlanResolver, ArgumentInputPlanResolver, arrayOfLength, arraysMatch, assertEdgeCapableStep, assertExecutableStep, assertListCapableStep, assertModifierStep, assertPageInfoCapableStep, BaseEventMap, BaseGraphQLArguments, BaseGraphQLRootValue, BaseGraphQLVariables, BaseStep, connection, ConnectionCapableStep, ConnectionStep, constant, ConstantStep, context, debugPlans, defer, Deferred, each, EdgeCapableStep, EdgeStep, EnumPlans, EnumValueApplyPlanResolver, error, ErrorStep, EventCallback, EventMapKey, ExecutableStep, execute, ExecutionEventEmitter, ExecutionEventMap, ExecutionExtra, exportAs, exportAsMany, FieldArgs, FieldInfo, FieldPlanResolver, FieldPlans, filter, FilterPlanMemo, first, FirstStep, getEnumValueConfig, grafast, GrafastArgumentConfig, GrafastError, GrafastFieldConfig, GrafastFieldConfigArgumentMap, grafast as grafastGraphql, grafastSync as grafastGraphqlSync, GrafastInputFieldConfig, GrafastInputFieldConfigMap, GrafastInputObjectType, GrafastObjectType, GrafastPlanJSON, GrafastPlans, grafastPrint, GrafastResultsList, GrafastResultStreamList, GrafastSubscriber, grafastSync, GrafastValuesList, GraphQLItemHandler, graphqlItemHandler, graphqlResolver, GraphQLResolverStep, groupBy, GroupByPlanMemo, InputObjectFieldApplyPlanResolver, InputObjectFieldInputPlanResolver, inputObjectFieldSpec, InputObjectPlans, InputObjectTypeInputPlanResolver, InputObjectTypeSpec, InputStep, InterfaceOrUnionPlans, isDev, isExecutableStep, isGrafastError, isListCapableStep, isListLikeStep, isModifierStep, isObjectLikeStep, isPromiseLike, isSafeError, isStreamableStep, JSONArray, JSONObject, JSONValue, lambda, LambdaStep, last, LastStep, list, ListCapableStep, listen, ListenStep, ListLikeStep, ListStep, listTransform, ListTransformItemPlanCallback, ListTransformOptions, ListTransformReduce, LoadedRecordStep, loadMany, LoadManyCallback, loadManyCallback, loadOne, LoadOneCallback, loadOneCallback, LoadOptions, LoadStep, makeDecodeNodeId, makeGrafastSchema, ModifierStep, newGrafastFieldConfigBuilder, newInputObjectTypeBuilder, newObjectTypeBuilder, node, NodeIdCodec, NodeIdHandler, NodeStep, noop, object, objectFieldSpec, ObjectLikeStep, ObjectPlanMeta, ObjectPlans, objectSpec, ObjectStep, ObjectTypeFields, ObjectTypeSpec, OperationPlan, operationPlan, OutputPlanForType, PageInfoCapableStep, partitionByIndex, PolymorphicData, PolymorphicStep, polymorphicWrap, PromiseOrDirect, proxy, ProxyStep, remapKeys, RemapKeysStep, reverse, reverseArray, ReverseStep, SafeError, ScalarPlanResolver, ScalarPlans, setter, SetterCapableStep, SetterStep, specFromNodeId, stepADependsOnStepB, stepAMayDependOnStepB, StepOptimizeOptions, stepsAreInSamePhase, StepStreamOptions, StreamableStep, stringifyPayload, stripAnsi, subscribe, TypedEventEmitter, UnbatchedExecutableStep, };
+export { __InputListStep, __InputObjectStep, __InputObjectStepWithDollars, __InputStaticLeafStep, __ItemStep, __ListTransformStep, __TrackedValueStep, __TrackedValueStepWithDollars, __ValueStep, $$bypassGraphQL, $$eventEmitter, $$extensions, $$idempotent, $$verbatim, access, AccessStep, ActualKeyByDesiredKey, applyTransforms, ApplyTransformsStep, ArgumentApplyPlanResolver, ArgumentInputPlanResolver, arrayOfLength, arraysMatch, assertEdgeCapableStep, assertExecutableStep, assertListCapableStep, assertModifierStep, assertPageInfoCapableStep, BaseEventMap, BaseGraphQLArguments, BaseGraphQLRootValue, BaseGraphQLVariables, BaseStep, connection, ConnectionCapableStep, ConnectionStep, constant, ConstantStep, context, debugPlans, defer, Deferred, each, EdgeCapableStep, EdgeStep, EnumPlans, EnumValueApplyPlanResolver, error, ErrorStep, EventCallback, EventMapKey, ExecutableStep, execute, ExecutionEventEmitter, ExecutionEventMap, ExecutionExtra, exportAs, exportAsMany, FieldArgs, FieldInfo, FieldPlanResolver, FieldPlans, filter, FilterPlanMemo, first, FirstStep, getEnumValueConfig, grafast, GrafastArgumentConfig, GrafastError, GrafastFieldConfig, GrafastFieldConfigArgumentMap, grafast as grafastGraphql, grafastSync as grafastGraphqlSync, GrafastInputFieldConfig, GrafastInputFieldConfigMap, GrafastInputObjectType, GrafastObjectType, GrafastPlanJSON, GrafastPlans, grafastPrint, GrafastResultsList, GrafastResultStreamList, GrafastSubscriber, grafastSync, GrafastValuesList, GraphQLItemHandler, graphqlItemHandler, graphqlResolver, GraphQLResolverStep, groupBy, GroupByPlanMemo, InputObjectFieldApplyPlanResolver, InputObjectFieldInputPlanResolver, inputObjectFieldSpec, InputObjectPlans, InputObjectTypeInputPlanResolver, InputObjectTypeSpec, InputStep, InterfaceOrUnionPlans, isDev, isExecutableStep, isGrafastError, isListCapableStep, isListLikeStep, isModifierStep, isObjectLikeStep, isPromiseLike, isSafeError, isStreamableStep, JSONArray, JSONObject, JSONValue, lambda, LambdaStep, last, LastStep, list, ListCapableStep, listen, ListenStep, ListLikeStep, ListStep, listTransform, ListTransformItemPlanCallback, ListTransformOptions, ListTransformReduce, LoadedRecordStep, loadMany, LoadManyCallback, loadManyCallback, loadOne, LoadOneCallback, loadOneCallback, LoadOptions, LoadStep, makeDecodeNodeId, makeGrafastSchema, Maybe, ModifierStep, newGrafastFieldConfigBuilder, newInputObjectTypeBuilder, newObjectTypeBuilder, node, NodeIdCodec, NodeIdHandler, NodeStep, noop, object, objectFieldSpec, ObjectLikeStep, ObjectPlanMeta, ObjectPlans, objectSpec, ObjectStep, ObjectTypeFields, ObjectTypeSpec, OperationPlan, operationPlan, OutputPlanForType, PageInfoCapableStep, partitionByIndex, PolymorphicData, PolymorphicStep, polymorphicWrap, PromiseOrDirect, proxy, ProxyStep, remapKeys, RemapKeysStep, reverse, reverseArray, ReverseStep, SafeError, ScalarPlanResolver, ScalarPlans, setter, SetterCapableStep, SetterStep, specFromNodeId, stepADependsOnStepB, stepAMayDependOnStepB, StepOptimizeOptions, stepsAreInSamePhase, StepStreamOptions, StreamableStep, stringifyPayload, stripAnsi, subscribe, TypedEventEmitter, UnbatchedExecutableStep, };
 export { hookArgs } from "./args.js";
 export { version } from "./version.js";
 /** @deprecated Renamed to 'applyTransforms' */
 export declare const deepEval: typeof applyTransforms;
 /** @deprecated Renamed to 'ApplyTransformsStep' */
 export declare const DeepEvalStep: typeof ApplyTransformsStep;
+declare global {
+    namespace Grafast {
+        type ExecutionArgs = Pick<GraphQLExecutionArgs, "schema" | "document" | "rootValue" | "variableValues" | "operationName"> & {
+            [$$hooked]?: boolean;
+            contextValue: Grafast.Context;
+        };
+        /**
+         * Details about the incoming GraphQL request - e.g. if it was sent over an
+         * HTTP request, the request itself so headers can be interrogated.
+         *
+         * It's anticipated this will be expanded via declaration merging, e.g. if
+         * your server is Koa v2 then `RequestContext.koav2` might be added.
+         */
+        interface RequestContext {
+        }
+        /**
+         * The GraphQL context our schemas expect, generally generated from details in Grafast.RequestContext
+         */
+        interface Context {
+        }
+        interface FieldExtensions {
+            plan?: FieldPlanResolver<any, any, any>;
+            subscribePlan?: FieldPlanResolver<any, any, any>;
+        }
+        interface ArgumentExtensions {
+            inputPlan?: ArgumentInputPlanResolver;
+            applyPlan?: ArgumentApplyPlanResolver;
+            autoApplyAfterParentPlan?: boolean;
+            autoApplyAfterParentSubscribePlan?: boolean;
+        }
+        interface InputObjectTypeExtensions {
+            inputPlan?: InputObjectTypeInputPlanResolver;
+        }
+        interface InputFieldExtensions {
+            inputPlan?: InputObjectFieldInputPlanResolver;
+            applyPlan?: InputObjectFieldApplyPlanResolver;
+            autoApplyAfterParentInputPlan?: boolean;
+            autoApplyAfterParentApplyPlan?: boolean;
+        }
+        interface ObjectTypeExtensions {
+            assertStep?: ((step: ExecutableStep) => asserts step is ExecutableStep) | {
+                new (...args: any[]): ExecutableStep;
+            } | null;
+        }
+        interface EnumTypeExtensions {
+        }
+        interface EnumValueExtensions {
+            /**
+             * EXPERIMENTAL!
+             *
+             * @internal
+             */
+            applyPlan?: EnumValueApplyPlanResolver<any>;
+        }
+        interface ScalarTypeExtensions {
+            plan?: ScalarPlanResolver;
+            inputPlan?: ScalarInputPlanResolver;
+            /**
+             * Set true if `serialize(serialize(foo)) === serialize(foo)` for all foo
+             */
+            idempotent?: boolean;
+        }
+        interface SchemaExtensions {
+            /**
+             * Maximum number of queries to store in this schema's query cache.
+             */
+            queryCacheMaxLength?: number;
+            /**
+             * The underlying query cache
+             */
+            [$$queryCache]?: LRU<string, DocumentNode | ReadonlyArray<GraphQLError>>;
+            /**
+             * Maximum number of operations to store an operation plan lookup cache for
+             */
+            operationsCacheMaxLength?: number;
+            /**
+             * Maximum number of operation plans to store in a single operation's cache
+             */
+            operationOperationPlansCacheMaxLength?: number;
+            /**
+             * The starting point for finding/storing the relevant OperationPlan for a request.
+             */
+            [$$cacheByOperation]?: LRU<OperationDefinitionNode, CacheByOperationEntry>;
+        }
+    }
+    namespace GraphileConfig {
+        interface GrafastOptions {
+            /**
+             * An object to merge into the GraphQL context. Alternatively, pass an
+             * (optionally asynchronous) function that returns an object to merge into
+             * the GraphQL context.
+             */
+            context?: Partial<Grafast.Context> | ((ctx: Partial<Grafast.RequestContext>, args: Grafast.ExecutionArgs) => PromiseOrValue<Partial<Grafast.Context>>);
+            /**
+             * A list of 'explain' types that should be included in `extensions.explain`.
+             *
+             * - `plan` will cause the plan JSON to be included
+             * - other values are dependent on the plugins in play
+             *
+             * If set to `true` then all possible explain types will be exposed.
+             */
+            explain?: boolean | string[];
+            timeouts?: GrafastTimeouts;
+        }
+        interface Preset {
+            /**
+             * Options that control how `grafast` should execute your GraphQL
+             * operations.
+             */
+            grafast?: GraphileConfig.GrafastOptions;
+        }
+        interface GrafastHooks {
+            args: PluginHook<(event: {
+                args: Grafast.ExecutionArgs;
+                ctx: Grafast.RequestContext;
+                resolvedPreset: GraphileConfig.ResolvedPreset;
+            }) => PromiseOrValue<void>>;
+        }
+        interface Plugin {
+            grafast?: {
+                hooks?: GrafastHooks;
+            };
+        }
+    }
+}
+declare module "graphql" {
+    interface GraphQLFieldExtensions<_TSource, _TContext, _TArgs = any> {
+        grafast?: Grafast.FieldExtensions;
+    }
+    interface GraphQLArgumentExtensions {
+        grafast?: Grafast.ArgumentExtensions;
+    }
+    interface GraphQLInputObjectTypeExtensions {
+        grafast?: Grafast.InputObjectTypeExtensions;
+    }
+    interface GraphQLInputFieldExtensions {
+        grafast?: Grafast.InputFieldExtensions;
+    }
+    interface GraphQLObjectTypeExtensions<_TSource = any, _TContext = any> {
+        grafast?: Grafast.ObjectTypeExtensions;
+    }
+    interface GraphQLEnumTypeExtensions {
+        grafast?: Grafast.EnumTypeExtensions;
+    }
+    interface GraphQLEnumValueExtensions {
+        grafast?: Grafast.EnumValueExtensions;
+    }
+    interface GraphQLScalarTypeExtensions {
+        grafast?: Grafast.ScalarTypeExtensions;
+    }
+    interface GraphQLSchemaExtensions {
+        grafast?: Grafast.SchemaExtensions;
+    }
+}
 //# sourceMappingURL=index.d.ts.map