grafast 0.1.1-beta.21 → 0.1.1-beta.23

package/dist/engine/lib/defaultPlanResolver.d.ts

@@ -1,6 +1,3 @@
 import type { FieldPlanResolver } from "../../interfaces.js";
-import type { Step } from "../../step.js";
-export declare const defaultPlanResolver: FieldPlanResolver<any, Step & {
-    get?: (field: string) => Step;
-}, any>;
+export declare const defaultPlanResolver: FieldPlanResolver;
 //# sourceMappingURL=defaultPlanResolver.d.ts.map

package/dist/engine/lib/defaultPlanResolver.js

@@ -2,10 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultPlanResolver = void 0;
 const access_js_1 = require("../../steps/access.js");
-const defaultPlanResolver = ($step, _, { fieldName }) => {
-    return typeof $step.get === "function"
-        ? $step.get(fieldName)
-        : (0, access_js_1.access)($step, [fieldName]);
-};
+const defaultPlanResolver = ($step, _, info) => (0, access_js_1.get)($step, info.fieldName);
 exports.defaultPlanResolver = defaultPlanResolver;
 //# sourceMappingURL=defaultPlanResolver.js.map

package/dist/engine/lib/withGlobalLayerPlan.d.ts

@@ -1,7 +1,9 @@
 import type { Step } from "../..";
 import type { LayerPlan } from "../LayerPlan";
-export declare function withGlobalLayerPlan<T, TThis = any, TArgs extends [...args: any[]] = [...args: any[]]>(layerPlan: LayerPlan, polymorphicPaths: ReadonlySet<string> | null, callback: (this: TThis, ...args: TArgs) => T, callbackThis?: TThis, ...callbackArgs: TArgs): T;
+export declare function withGlobalLayerPlan<T, TThis = any, TArgs extends [...args: any[]] = [...args: any[]]>(layerPlan: LayerPlan, polymorphicPaths: ReadonlySet<string> | null, planningPath: string | null, callback: (this: TThis, ...args: TArgs) => T, callbackThis?: TThis, ...callbackArgs: TArgs): T;
 export declare function currentLayerPlan(): LayerPlan;
 export declare function currentPolymorphicPaths(): ReadonlySet<string> | null;
+/** UNUSED */
+export declare function currentPlanningPath(): string | undefined;
 export declare function isUnaryStep($step: Step): boolean;
 //# sourceMappingURL=withGlobalLayerPlan.d.ts.map

package/dist/engine/lib/withGlobalLayerPlan.js

@@ -3,20 +3,29 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.withGlobalLayerPlan = withGlobalLayerPlan;
 exports.currentLayerPlan = currentLayerPlan;
 exports.currentPolymorphicPaths = currentPolymorphicPaths;
+exports.currentPlanningPath = currentPlanningPath;
 exports.isUnaryStep = isUnaryStep;
+const global_js_1 = require("../../global.js");
 let globalData_layerPlan = undefined;
 let globalData_polymorphicPaths = undefined;
-function withGlobalLayerPlan(layerPlan, polymorphicPaths, callback, callbackThis, ...callbackArgs) {
+let globalData_planningPath = undefined;
+function withGlobalLayerPlan(layerPlan, polymorphicPaths, planningPath, callback, callbackThis, ...callbackArgs) {
     const oldLayerPlan = globalData_layerPlan;
     globalData_layerPlan = layerPlan;
     const oldPolymorphicPaths = globalData_polymorphicPaths;
     globalData_polymorphicPaths = polymorphicPaths;
+    const oldPlanningPath = globalData_planningPath;
+    // Keep the old planning path if we've not been given a new one
+    if (planningPath != null) {
+        globalData_planningPath = planningPath;
+    }
     try {
         return callback.apply(callbackThis, callbackArgs);
     }
     finally {
         globalData_layerPlan = oldLayerPlan;
         globalData_polymorphicPaths = oldPolymorphicPaths;
+        globalData_planningPath = oldPlanningPath;
     }
 }
 function currentLayerPlan() {
@@ -33,6 +42,15 @@ function currentPolymorphicPaths() {
     }
     return globalData_polymorphicPaths;
 }
+/** UNUSED */
+function currentPlanningPath() {
+    const opPlan = (0, global_js_1.operationPlan)();
+    if (opPlan.phase === "plan" && globalData_planningPath === undefined) {
+        // This might happen during deduplicate for example
+        console.warn("GrafastInternalWarning<6a484dc3-a690-493c-b8b3-d6196bf2c290>: currentPlanningPath could not retrieve the current path even in 'plan' phase");
+    }
+    return globalData_planningPath;
+}
 function isUnaryStep($step) {
     return $step._isUnary;
 }

package/dist/envelop.js

@@ -13,7 +13,7 @@ function processExplain(explainAllowed, explainHeaders) {
     const explainHeader = Array.isArray(explainHeaders)
         ? explainHeaders.join(",")
         : explainHeaders;
-    if (!explainHeader) {
+    if (typeof explainHeader !== "string") {
         return undefined;
     }
     const explainParts = explainHeader.split(",");
@@ -40,9 +40,20 @@ const useGrafast = (options = {}) => {
         },
         async onSubscribe(opts) {
             const ctx = opts.args.contextValue;
-            const explainHeaders = (ctx?.req?.headers ||
+            const headersObj = ctx?.req?.headers ||
                 ctx?.request?.headers ||
-                ctx?.connectionParams)?.["x-graphql-explain"];
+                ctx?.normalizedConnectionParams ||
+                ctx?.connectionParams;
+            let explainHeaders;
+            if (headersObj) {
+                explainHeaders = headersObj["x-graphql-explain"];
+                if (explainHeaders == null) {
+                    const key = Object.keys(headersObj).find((k) => k.toLowerCase() === "x-graphql-explain");
+                    if (key != null) {
+                        explainHeaders = headersObj[key];
+                    }
+                }
+            }
             const explain = processExplain(explainAllowed, explainHeaders);
             opts.setSubscribeFn(async (args) => (0, subscribe_js_1.subscribe)(args, (0, graphile_config_1.resolvePreset)({
                 grafast: { explain },

package/dist/error.d.ts

@@ -1,5 +1,5 @@
+import { $$safeError } from "./constants.js";
 import type { ExecutionEntryFlags } from "./interfaces.js";
-import { $$safeError } from "./interfaces.js";
 declare const $$flagged: unique symbol;
 /**
  * Wrapper for errors to return (rather than throw or reject) from user code.

package/dist/error.js

@@ -5,15 +5,15 @@ exports.SafeError = exports.$$inhibit = void 0;
 exports.flagError = flagError;
 exports.isFlaggedValue = isFlaggedValue;
 exports.isSafeError = isSafeError;
+const constants_js_1 = require("./constants.js");
 const dev_js_1 = require("./dev.js");
 const inspect_js_1 = require("./inspect.js");
-const interfaces_js_1 = require("./interfaces.js");
 const $$flagged = Symbol("grafastFlaggedValue");
 function flaggedValueToString() {
-    if (this.flags & interfaces_js_1.FLAG_ERROR && this.value instanceof Error) {
+    if (this.flags & constants_js_1.FLAG_ERROR && this.value instanceof Error) {
         return String(this.value);
     }
-    else if (this.flags & interfaces_js_1.FLAG_INHIBITED && this.value === null) {
+    else if (this.flags & constants_js_1.FLAG_INHIBITED && this.value === null) {
         return "INHIBIT";
     }
     else {
@@ -22,10 +22,10 @@ function flaggedValueToString() {
 }
 function flaggedValue(flags, value, planId) {
     if (dev_js_1.isDev) {
-        if (value === null && !(flags & interfaces_js_1.FLAG_NULL)) {
+        if (value === null && !(flags & constants_js_1.FLAG_NULL)) {
             throw new Error(`flaggedValue called with null, but not flagged as null.`);
         }
-        if (value === null && !(flags & interfaces_js_1.FLAG_INHIBITED)) {
+        if (value === null && !(flags & constants_js_1.FLAG_INHIBITED)) {
             throw new Error(`flaggedValue called with null, but not flagged as inhibited.`);
         }
     }
@@ -37,13 +37,13 @@ function flaggedValue(flags, value, planId) {
         toString: flaggedValueToString,
     };
 }
-exports.$$inhibit = flaggedValue(interfaces_js_1.FLAG_NULL | interfaces_js_1.FLAG_INHIBITED, null, null);
+exports.$$inhibit = flaggedValue(constants_js_1.FLAG_NULL | constants_js_1.FLAG_INHIBITED, null, null);
 /**
  * Used to wrap error values to have Grafast treat them as if they were
  * thrown/rejected (rather than just regular values).
  */
 function flagError(value, planId = null) {
-    return flaggedValue(interfaces_js_1.FLAG_ERROR, value, planId);
+    return flaggedValue(constants_js_1.FLAG_ERROR, value, planId);
 }
 /**
  * Is this a flagged value?
@@ -54,7 +54,7 @@ function isFlaggedValue(value) {
     return Object.hasOwn(value, $$flagged);
 }
 class SafeError extends Error {
-    static { _a = interfaces_js_1.$$safeError; }
+    static { _a = constants_js_1.$$safeError; }
     static { this.$$export = {
         moduleName: "grafast",
         exportName: "SafeError",
@@ -68,6 +68,6 @@ class SafeError extends Error {
 }
 exports.SafeError = SafeError;
 function isSafeError(error) {
-    return error[interfaces_js_1.$$safeError];
+    return error[constants_js_1.$$safeError];
 }
 //# sourceMappingURL=error.js.map

package/dist/establishOperationPlan.d.ts

@@ -1,6 +1,7 @@
 import type { GraphQLSchema, OperationDefinitionNode } from "graphql";
 import { OperationPlan } from "./index.js";
 import type { BaseGraphQLRootValue, BaseGraphQLVariables, Fragments } from "./interfaces.js";
+import type { GrafastOperationOptions } from "./prepare.js";
 /**
  * Implements the `EstablishOpPlan` algorithm.
  *
@@ -8,5 +9,5 @@ import type { BaseGraphQLRootValue, BaseGraphQLVariables, Fragments } from "./in
  * instead accept operation and fragments since they're easier to get a hold of
  * in GraphQL.js.
  */
-export declare function establishOperationPlan<TVariables extends BaseGraphQLVariables = BaseGraphQLVariables, TContext extends Grafast.Context = Grafast.Context, TRootValue extends BaseGraphQLRootValue = BaseGraphQLRootValue>(schema: GraphQLSchema, operation: OperationDefinitionNode, fragments: Fragments, variableValues: TVariables, context: TContext, rootValue: TRootValue, planningTimeout?: number | null): OperationPlan;
+export declare function establishOperationPlan<TVariables extends BaseGraphQLVariables = BaseGraphQLVariables, TContext extends Grafast.Context = Grafast.Context, TRootValue extends BaseGraphQLRootValue = BaseGraphQLRootValue>(schema: GraphQLSchema, operation: OperationDefinitionNode, fragments: Fragments, variableValues: TVariables, context: TContext, rootValue: TRootValue, options: GrafastOperationOptions): OperationPlan;
 //# sourceMappingURL=establishOperationPlan.d.ts.map

package/dist/establishOperationPlan.js

@@ -4,10 +4,10 @@ exports.establishOperationPlan = establishOperationPlan;
 const tslib_1 = require("tslib");
 const lru_1 = tslib_1.__importDefault(require("@graphile/lru"));
 const debug_1 = tslib_1.__importDefault(require("debug"));
+const constants_js_1 = require("./constants.js");
 const constraints_js_1 = require("./constraints.js");
 const dev_js_1 = require("./dev.js");
 const index_js_1 = require("./index.js");
-const interfaces_js_1 = require("./interfaces.js");
 const timeSource_js_1 = require("./timeSource.js");
 const debug = (0, debug_1.default)("grafast:establishOperationPlan");
 // How long is a timeout valid for? Here I've set it to 60 seconds.
@@ -70,9 +70,9 @@ function isOperationPlanResultCompatible(operationPlan, variableValues, context,
  * instead accept operation and fragments since they're easier to get a hold of
  * in GraphQL.js.
  */
-// eslint-disable-next-line @typescript-eslint/ban-types
-function establishOperationPlan(schema, operation, fragments, variableValues, context, rootValue, planningTimeout = null) {
-    let cacheByOperation = schema.extensions.grafast?.[interfaces_js_1.$$cacheByOperation];
+function establishOperationPlan(schema, operation, fragments, variableValues, context, rootValue, options) {
+    const planningTimeout = options.timeouts?.planning;
+    let cacheByOperation = schema.extensions.grafast?.[constants_js_1.$$cacheByOperation];
     let cache = cacheByOperation?.get(operation);
     // These two variables to make it easy to trim the linked list later.
     let count = 0;
@@ -88,8 +88,8 @@ function establishOperationPlan(schema, operation, fragments, variableValues, co
                 const { error, operationPlan } = value;
                 if (error != null) {
                     if (error instanceof index_js_1.SafeError) {
-                        if (error.extensions?.[interfaces_js_1.$$timeout] != null) {
-                            if (error.extensions[interfaces_js_1.$$ts] < timeSource_js_1.timeSource.now() - TIMEOUT_TIMEOUT) {
+                        if (error.extensions?.[constants_js_1.$$timeout] != null) {
+                            if (error.extensions[constants_js_1.$$ts] < timeSource_js_1.timeSource.now() - TIMEOUT_TIMEOUT) {
                                 // Remove this out of date timeout
                                 linkedItem = linkedItem.next;
                                 if (previousItem !== null) {
@@ -100,8 +100,8 @@ function establishOperationPlan(schema, operation, fragments, variableValues, co
                                 }
                                 continue;
                             }
-                            if (planningTimeout !== null &&
-                                error.extensions[interfaces_js_1.$$timeout] >= planningTimeout) {
+                            if (planningTimeout != null &&
+                                error.extensions[constants_js_1.$$timeout] >= planningTimeout) {
                                 // It was a timeout error - do not retry
                                 throw error;
                             }
@@ -146,7 +146,7 @@ function establishOperationPlan(schema, operation, fragments, variableValues, co
     const contextConstraints = [];
     const rootValueConstraints = [];
     try {
-        operationPlan = new index_js_1.OperationPlan(schema, operation, fragments, variableValuesConstraints, variableValues, contextConstraints, context, rootValueConstraints, rootValue, planningTimeout);
+        operationPlan = new index_js_1.OperationPlan(schema, operation, fragments, variableValuesConstraints, variableValues, contextConstraints, context, rootValueConstraints, rootValue, options);
     }
     catch (e) {
         error = e;
@@ -159,7 +159,7 @@ function establishOperationPlan(schema, operation, fragments, variableValues, co
         cacheByOperation = new lru_1.default({
             maxLength: schema.extensions.grafast.operationsCacheMaxLength ?? 500,
         });
-        schema.extensions.grafast[interfaces_js_1.$$cacheByOperation] = cacheByOperation;
+        schema.extensions.grafast[constants_js_1.$$cacheByOperation] = cacheByOperation;
     }
     const establishOperationPlanResult = {
         variableValuesConstraints,

package/dist/execute.js

@@ -4,9 +4,9 @@ exports.withGrafastArgs = withGrafastArgs;
 exports.execute = execute;
 const tslib_1 = require("tslib");
 const eventemitter3_1 = tslib_1.__importDefault(require("eventemitter3"));
+const constants_js_1 = require("./constants.js");
 const dev_js_1 = require("./dev.js");
 const inspect_js_1 = require("./inspect.js");
-const interfaces_js_1 = require("./interfaces.js");
 const middleware_js_1 = require("./middleware.js");
 const prepare_js_1 = require("./prepare.js");
 const utils_js_1 = require("./utils.js");
@@ -36,8 +36,8 @@ function withGrafastArgs(args) {
         const eventEmitter = new eventemitter3_1.default();
         const explainOperations = [];
         args.rootValue = Object.assign(Object.create(null), args.rootValue, {
-            [interfaces_js_1.$$eventEmitter]: eventEmitter,
-            [interfaces_js_1.$$extensions]: {
+            [constants_js_1.$$eventEmitter]: eventEmitter,
+            [constants_js_1.$$extensions]: {
                 explain: {
                     operations: explainOperations,
                 },
@@ -53,12 +53,14 @@ function withGrafastArgs(args) {
             eventEmitter.removeListener("explainOperation", handleExplainOperation);
         };
     }
-    const rootValue = (0, prepare_js_1.grafastPrepare)(args, {
+    const operationOptions = {
         explain: options?.explain,
         timeouts: options?.timeouts,
+        maxPlanningDepth: options?.maxPlanningDepth,
         // TODO: Delete this
         outputDataAsString: args.outputDataAsString,
-    });
+    };
+    const rootValue = (0, prepare_js_1.grafastPrepare)(args, operationOptions);
     if (unlisten !== null) {
         Promise.resolve(rootValue).then(unlisten, unlisten);
     }

package/dist/global.d.ts

@@ -1,3 +1,13 @@
+import type { OperationPlan } from "./engine/OperationPlan.js";
+import type { __ValueStep } from "./steps/index.js";
 export declare function setDebug(newDebug: boolean): void;
 export declare function getDebug(): boolean;
+export declare function operationPlan(): OperationPlan;
+export declare function context(): __ValueStep<Grafast.Context>;
+export declare function rootValue(): __ValueStep<Record<string, any>>;
+/**
+ * Turns on debug mode, calls the callback, and then turns debug mode back off
+ * again.
+ */
+export declare function debugPlans<T>(callback: () => T): T;
 //# sourceMappingURL=global.d.ts.map

package/dist/global.js

@@ -2,6 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setDebug = setDebug;
 exports.getDebug = getDebug;
+exports.operationPlan = operationPlan;
+exports.context = context;
+exports.rootValue = rootValue;
+exports.debugPlans = debugPlans;
+const withGlobalLayerPlan_js_1 = require("./engine/lib/withGlobalLayerPlan.js");
 let debug = false;
 function setDebug(newDebug) {
     debug = newDebug;
@@ -9,4 +14,24 @@ function setDebug(newDebug) {
 function getDebug() {
     return debug;
 }
+function operationPlan() {
+    return (0, withGlobalLayerPlan_js_1.currentLayerPlan)().operationPlan;
+}
+function context() {
+    return operationPlan().contextStep;
+}
+function rootValue() {
+    return operationPlan().rootValueStep;
+}
+/**
+ * Turns on debug mode, calls the callback, and then turns debug mode back off
+ * again.
+ */
+function debugPlans(callback) {
+    const oldDebug = getDebug();
+    setDebug(true);
+    const result = callback();
+    setDebug(oldDebug);
+    return result;
+}
 //# sourceMappingURL=global.js.map

package/dist/grafastGraphql.js

@@ -5,10 +5,10 @@ exports.grafastSync = grafastSync;
 const tslib_1 = require("tslib");
 const lru_1 = tslib_1.__importDefault(require("@graphile/lru"));
 const graphql = tslib_1.__importStar(require("graphql"));
+const constants_js_1 = require("./constants.js");
 const error_js_1 = require("./error.js");
 const execute_js_1 = require("./execute.js");
 const index_js_1 = require("./index.js");
-const interfaces_js_1 = require("./interfaces.js");
 const middleware_js_1 = require("./middleware.js");
 const utils_js_1 = require("./utils.js");
 const { GraphQLError, parse, Source, validate, validateSchema } = graphql;
@@ -22,6 +22,7 @@ let calculateQueryHash;
 try {
     let lastString;
     let lastHash;
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
     const createHash = require("crypto").createHash;
     if (typeof createHash !== "function") {
         throw new Error("Failed to load createHash");
@@ -38,7 +39,7 @@ catch {
     calculateQueryHash = (str) => str;
 }
 const parseAndValidate = (gqlSchema, stringOrSource) => {
-    let queryCache = gqlSchema.extensions.grafast?.[interfaces_js_1.$$queryCache];
+    let queryCache = gqlSchema.extensions.grafast?.[constants_js_1.$$queryCache];
     if (!queryCache) {
         const cacheSize = gqlSchema.extensions.grafast?.queryCacheMaxLength ??
             defaultQueryCacheMaxSize;
@@ -46,7 +47,7 @@ const parseAndValidate = (gqlSchema, stringOrSource) => {
         if (!gqlSchema.extensions.grafast) {
             gqlSchema.extensions.grafast = Object.create(null);
         }
-        gqlSchema.extensions.grafast[interfaces_js_1.$$queryCache] = queryCache;
+        gqlSchema.extensions.grafast[constants_js_1.$$queryCache] = queryCache;
     }
     // Only cache queries that are less than 100kB, we don't want DOS attacks
     // attempting to exhaust our memory.

package/dist/grafastPrint.js

@@ -8,7 +8,9 @@ exports.grafastPrint = grafastPrint;
 exports.ansiPad = ansiPad;
 const tslib_1 = require("tslib");
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const constants_js_1 = require("./constants.js");
 const executeBucket_js_1 = require("./engine/executeBucket.js");
+const LayerPlan_js_1 = require("./engine/LayerPlan.js");
 const OutputPlan_js_1 = require("./engine/OutputPlan.js");
 const inspect_js_1 = require("./inspect.js");
 const step_js_1 = require("./step.js");
@@ -58,6 +60,9 @@ function _grafastPrint(symbol, seen) {
     if (symbol instanceof step_js_1.Step) {
         return String(symbol);
     }
+    if (symbol instanceof LayerPlan_js_1.LayerPlan) {
+        return String(symbol);
+    }
     if (Array.isArray(symbol)) {
         if (seen.has(symbol)) {
             return chalk_1.default.gray `(loop)`;
@@ -130,7 +135,10 @@ function indent(level, string) {
     return " ".repeat(level) + string.replace(/\n/g, `\n${" ".repeat(level)}`);
 }
 function recursivePrintBucket(bucket, indentLevel = 0) {
-    return indent(indentLevel, `Bucket for ${bucket.layerPlan} (size = ${bucket.size}):
+    return indent(indentLevel, `Bucket for ${bucket.layerPlan} (size = ${bucket.size}):${bucket.polymorphicPathList.some((p) => p != null)
+        ? `
+${bucket.polymorphicPathList.map((p, i) => `${String(i).padStart(4, " ")}: ${p}`)}`
+        : ""}
   Store:
 ${indent(4, printStore(bucket))}
   Children:
@@ -162,13 +170,13 @@ function printStore(bucket) {
         }
         else if (val.isBatch) {
             const step = bucket.layerPlan.operationPlan.stepTracker.getStepById(key, true);
-            output.push(`${printKey} (BATCH): ${step ?? "-"}\n${indent(2, val.entries
-                .map((e, i) => `${String(i).padStart(3, " ")}: flags=${String(val._flagsAt(i)).padStart(2, " ")} value=${indentIfMultiline((0, inspect_js_1.inspect)(val.at(i), PRINT_STORE_INSPECT_OPTIONS))}`)
+            output.push(`${printKey} (BATCH): ${step ?? "-"} ${[...(step?.polymorphicPaths ?? [])]}\n${indent(2, val.entries
+                .map((e, i) => `${String(i).padStart(3, " ")}: flags=${printFlags(val._flagsAt(i))} value=${indentIfMultiline((0, inspect_js_1.inspect)(val.at(i), PRINT_STORE_INSPECT_OPTIONS))}`)
                 .join("\n"))}`);
         }
         else {
             const step = bucket.layerPlan.operationPlan.stepTracker.getStepById(key, true);
-            output.push(`${printKey} (UNARY/${String(val._entryFlags).padStart(2, " ")}) ${step ?? "-"}\n${indent(4, (0, inspect_js_1.inspect)(val.value, PRINT_STORE_INSPECT_OPTIONS))}`);
+            output.push(`${printKey} (UNARY/${printFlags(val._entryFlags)}) ${step ?? "-"} ${[...(step?.polymorphicPaths ?? [])]}\n${indent(4, (0, inspect_js_1.inspect)(val.value, PRINT_STORE_INSPECT_OPTIONS))}`);
         }
     }
     return output.join("\n") || "EMPTY";
@@ -235,4 +243,28 @@ function ansiPad(ansiString, targetLength, fill, position) {
         return ansiString;
     }
 }
+function printFlags(flags) {
+    if (flags === undefined)
+        return "  ?  ";
+    if (flags === 0)
+        return "     ";
+    // This should not fire, added in case we add future flags and forget to update this
+    if (flags !==
+        (flags &
+            (constants_js_1.FLAG_POLY_SKIPPED |
+                constants_js_1.FLAG_ERROR |
+                constants_js_1.FLAG_NULL |
+                constants_js_1.FLAG_INHIBITED |
+                constants_js_1.FLAG_STOPPED))) {
+        return String(flags).padStart(5, " ");
+    }
+    let flagString = "";
+    // Alphabetically sorted to avoid an unfortunate word they would spell
+    flagString += flags & constants_js_1.FLAG_ERROR ? "E" : " ";
+    flagString += flags & constants_js_1.FLAG_INHIBITED ? "I" : " ";
+    flagString += flags & constants_js_1.FLAG_NULL ? "N" : " ";
+    flagString += flags & constants_js_1.FLAG_POLY_SKIPPED ? "P" : " ";
+    flagString += flags & constants_js_1.FLAG_STOPPED ? "S" : " ";
+    return flagString;
+}
 //# sourceMappingURL=grafastPrint.js.map

package/dist/index.d.ts

@@ -6,7 +6,9 @@ import type { DataFromObjectSteps } from "./steps/object.js";
 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";
+import { AbstractTypePlan, DeprecatedInputObjectPlan, DeprecatedObjectPlan, EnumPlan, EnumValueConfig, EnumValueInput, FieldPlan, GrafastSchemaConfig, InputFieldPlan, InputObjectPlan, InterfacePlan, makeGrafastSchema, ObjectFieldConfig, ObjectPlan, ScalarPlan, UnionPlan } from "./makeGrafastSchema.js";
+import type { $$cacheByOperation, $$hooked, $$queryCache } from "./constants.js";
+import { $$bypassGraphQL, $$eventEmitter, $$extensions, $$idempotent, $$verbatim, DEFAULT_ACCEPT_FLAGS } from "./constants.js";
 import { defer, Deferred } from "./deferred.js";
 import { isDev, noop } from "./dev.js";
 import { defaultPlanResolver } from "./engine/lib/defaultPlanResolver.js";
@@ -14,22 +16,22 @@ import { isUnaryStep } from "./engine/lib/withGlobalLayerPlan.js";
 import { OperationPlan } from "./engine/OperationPlan.js";
 import { $$inhibit, flagError, isSafeError, SafeError } from "./error.js";
 import { execute } from "./execute.js";
+import { context, debugPlans, operationPlan, rootValue } from "./global.js";
 import { grafast, grafastSync } from "./grafastGraphql.js";
-import type { $$cacheByOperation, $$hooked, $$queryCache, ArgumentApplyPlanResolver, BatchExecutionValue, CacheByOperationEntry, DataFromStep, EnumValueApplyResolver, EstablishOperationPlanEvent, ExecuteEvent, ExecuteStepEvent, ExecutionValue, GrafastExecutionArgs, GrafastTimeouts, InputObjectFieldApplyResolver, InputObjectTypeBakedInfo, InputObjectTypeBakedResolver, ParseAndValidateEvent, PrepareArgsEvent, ScalarInputPlanResolver, UnaryExecutionValue, ValidateSchemaEvent } from "./interfaces.js";
-import { $$bypassGraphQL, $$eventEmitter, $$extensions, $$idempotent, $$verbatim, BaseEventMap, BaseGraphQLArguments, BaseGraphQLRootValue, BaseGraphQLVariables, EventCallback, EventMapKey, ExecutionDetails, ExecutionDetailsStream, ExecutionEventEmitter, ExecutionEventMap, ExecutionExtra, ExecutionResults, ExecutionResultValue, FieldArg, FieldArgs, FieldInfo, FieldPlanResolver, GrafastArgumentConfig, GrafastFieldConfig, GrafastFieldConfigArgumentMap, GrafastInputFieldConfig, GrafastPlanJSON, GrafastResultsList, GrafastResultStreamList, GrafastSubscriber, GrafastValuesList, JSONArray, JSONObject, JSONValue, Maybe, NodeIdCodec, NodeIdHandler, OutputPlanForType, PolymorphicData, PromiseOrDirect, ScalarPlanResolver, StepOptimizeOptions, StepStreamOptions, TypedEventEmitter, UnbatchedExecutionExtra } from "./interfaces.js";
+import { inspect } from "./inspect.js";
+import type { AbstractTypePlanner, ArgumentApplyPlanResolver, BaseEventMap, BaseGraphQLArguments, BaseGraphQLRootValue, BaseGraphQLVariables, BatchExecutionValue, CacheByOperationEntry, DataFromStep, EnumValueApplyResolver, EstablishOperationPlanEvent, EventCallback, EventMapKey, ExecuteEvent, ExecuteStepEvent, ExecutionDetails, ExecutionDetailsStream, ExecutionEventEmitter, ExecutionEventMap, ExecutionExtra, ExecutionResults, ExecutionResultValue, ExecutionValue, FieldArg, FieldArgs, FieldInfo, FieldPlanResolver, GrafastArgumentConfig, GrafastExecutionArgs, GrafastFieldConfig, GrafastFieldConfigArgumentMap, GrafastInputFieldConfig, GrafastPlanJSON, GrafastResultsList, GrafastResultStreamList, GrafastSubscriber, GrafastTimeouts, GrafastValuesList, InputObjectFieldApplyResolver, InputObjectTypeBakedInfo, InputObjectTypeBakedResolver, JSONArray, JSONObject, JSONValue, Maybe, NodeIdCodec, NodeIdHandler, ParseAndValidateEvent, PlanTypeInfo, PrepareArgsEvent, PromiseOrDirect, ScalarInputPlanResolver, ScalarPlanResolver, StepOptimizeOptions, StepStreamOptions, TypedEventEmitter, UnaryExecutionValue, UnbatchedExecutionExtra, ValidateSchemaEvent } from "./interfaces.js";
 import { getGrafastMiddleware } from "./middleware.js";
 import type { Multistep, UnwrapMultistep } from "./multistep.js";
 import { multistep } from "./multistep.js";
 import { getNullableInputTypeAtPath } from "./operationPlan-input.js";
-import { polymorphicWrap } from "./polymorphic.js";
-import { assertExecutableStep, assertListCapableStep, assertStep, isExecutableStep, isListCapableStep, isListLikeStep, isObjectLikeStep, isStep, ListCapableStep, ListLikeStep, ObjectLikeStep, PolymorphicStep, Step, UnbatchedStep } from "./step.js";
-import { __FlagStep, __InputListStep, __InputObjectStep, __InputObjectStepWithDollars, __InputStaticLeafStep, __ItemStep, __ListTransformStep, __TrackedValueStep, __TrackedValueStepWithDollars, __ValueStep, access, AccessStep, ActualKeyByDesiredKey, applyInput, ApplyInputStep, applyTransforms, ApplyTransformsStep, assertEdgeCapableStep, assertModifier, assertNotNull, assertPageInfoCapableStep, bakedInput, bakedInputRuntime, BakedInputStep, condition, ConditionStep, connection, ConnectionCapableStep, ConnectionStep, constant, ConstantStep, context, createObjectAndApplyChildren, debugPlans, each, EdgeCapableStep, EdgeStep, error, ErrorStep, filter, FilterPlanMemo, first, FirstStep, GraphQLItemHandler, graphqlItemHandler, graphqlResolver, GraphQLResolverStep, groupBy, GroupByPlanMemo, inhibitOnNull, isModifier, lambda, LambdaStep, last, LastStep, list, listen, ListenStep, ListStep, listTransform, ListTransformItemPlanCallback, ListTransformOptions, ListTransformReduce, LoadedRecordStep, loadMany, LoadManyCallback, loadManyCallback, loadOne, LoadOneCallback, loadOneCallback, LoadOptions, LoadStep, makeDecodeNodeId, makeDecodeNodeIdRuntime, Modifier, node, nodeIdFromNode, NodeStep, object, ObjectPlanMeta, ObjectStep, operationPlan, PageInfoCapableStep, partitionByIndex, polymorphicBranch, PolymorphicBranchMatcher, PolymorphicBranchMatchers, PolymorphicBranchStep, proxy, ProxyStep, remapKeys, RemapKeysStep, reverse, reverseArray, ReverseStep, rootValue, Setter, setter, SetterCapable, sideEffect, SideEffectStep, specFromNodeId, trackedContext, trackedRootValue, trap, TRAP_ERROR, TRAP_ERROR_OR_INHIBITED, TRAP_INHIBITED } from "./steps/index.js";
+import { assertExecutableStep, assertListCapableStep, assertStep, isExecutableStep, isListCapableStep, isListLikeStep, isObjectLikeStep, isStep, ListCapableStep, ListLikeStep, ObjectLikeStep, Step, UnbatchedStep } from "./step.js";
+import { __FlagStep, __InputListStep, __InputObjectStep, __InputObjectStepWithDollars, __InputStaticLeafStep, __ItemStep, __ListTransformStep, __TrackedValueStep, __TrackedValueStepWithDollars, __ValueStep, access, AccessStep, ActualKeyByDesiredKey, applyInput, ApplyInputStep, applyTransforms, ApplyTransformsStep, assertEdgeCapableStep, assertModifier, assertNotNull, assertPageInfoCapableStep, bakedInput, bakedInputRuntime, BakedInputStep, coalesce, CoalesceStep, condition, ConditionStep, connection, ConnectionCapableStep, ConnectionStep, constant, ConstantStep, createObjectAndApplyChildren, each, EdgeCapableStep, EdgeStep, error, ErrorStep, filter, FilterPlanMemo, first, FirstStep, get, graphqlResolver, GraphQLResolverStep, groupBy, GroupByPlanMemo, inhibitOnNull, isModifier, lambda, LambdaStep, last, LastStep, list, listen, ListenStep, ListStep, listTransform, ListTransformItemPlanCallback, ListTransformOptions, ListTransformReduce, LoadedRecordStep, loadMany, LoadManyCallback, loadManyCallback, loadOne, LoadOneCallback, loadOneCallback, LoadOptions, LoadStep, makeDecodeNodeId, makeDecodeNodeIdRuntime, Modifier, node, nodeIdFromNode, NodeStep, object, ObjectPlanMeta, ObjectStep, PageInfoCapableStep, partitionByIndex, proxy, ProxyStep, remapKeys, RemapKeysStep, reverse, reverseArray, ReverseStep, Setter, setter, SetterCapable, sideEffect, SideEffectStep, specFromNodeId, trap, TRAP_ERROR, TRAP_ERROR_OR_INHIBITED, TRAP_INHIBITED } from "./steps/index.js";
 import { stringifyPayload } from "./stringifyPayload.js";
 import { stripAnsi } from "./stripAnsi.js";
 import { subscribe } from "./subscribe.js";
-import { arrayOfLength, arraysMatch, getEnumValueConfig, getEnumValueConfigs, GrafastInputFieldConfigMap, GrafastInputObjectType, GrafastObjectType, inputObjectFieldSpec, InputObjectTypeSpec, isPromiseLike, newGrafastFieldConfigBuilder, newInputObjectTypeBuilder, newObjectTypeBuilder, objectFieldSpec, objectSpec, ObjectTypeFields, ObjectTypeSpec, stepADependsOnStepB, stepAMayDependOnStepB, stepsAreInSamePhase } from "./utils.js";
+import { arrayOfLength, arraysMatch, getEnumValueConfig, getEnumValueConfigs, GrafastInputFieldConfigMap, GrafastInputObjectType, GrafastObjectType, inputObjectFieldSpec, InputObjectTypeSpec, isPromiseLike, mapsMatch, newGrafastFieldConfigBuilder, newInputObjectTypeBuilder, newObjectTypeBuilder, objectFieldSpec, objectSpec, ObjectTypeFields, ObjectTypeSpec, recordsMatch, setsMatch, stepADependsOnStepB, stepAMayDependOnStepB, stepAShouldTryAndInlineIntoStepB, stepsAreInSamePhase } from "./utils.js";
 export { isAsyncIterable } from "iterall";
-export { __FlagStep, __InputListStep, __InputObjectStep, __InputObjectStepWithDollars, __InputStaticLeafStep, __ItemStep, __ListTransformStep, __TrackedValueStep, __TrackedValueStepWithDollars, __ValueStep, $$bypassGraphQL, $$eventEmitter, $$extensions, $$idempotent, $$inhibit, $$verbatim, access, AccessStep, ActualKeyByDesiredKey, applyInput, ApplyInputStep, applyTransforms, ApplyTransformsStep, arrayOfLength, arraysMatch, assertEdgeCapableStep, assertExecutableStep, assertListCapableStep, assertModifier, assertNotNull, assertPageInfoCapableStep, assertStep, bakedInput, bakedInputRuntime, BakedInputStep, BaseEventMap, BaseGraphQLArguments, BaseGraphQLRootValue, BaseGraphQLVariables, BatchExecutionValue, condition, ConditionStep, connection, ConnectionCapableStep, ConnectionStep, constant, ConstantStep, context, createObjectAndApplyChildren, DataFromObjectSteps, DataFromStep, debugPlans, defaultPlanResolver, defer, Deferred, each, EdgeCapableStep, EdgeStep, EnumPlans, error, ErrorStep, EventCallback, EventMapKey, Step as ExecutableStep, execute, ExecutionDetails, ExecutionDetailsStream, ExecutionEventEmitter, ExecutionEventMap, ExecutionExtra, ExecutionResults, ExecutionResultValue, ExecutionValue, exportAs, exportAsMany, FieldArg, FieldArgs, FieldInfo, FieldPlanResolver, FieldPlans, filter, FilterPlanMemo, first, FirstStep, flagError, getEnumValueConfig, getEnumValueConfigs, getGrafastMiddleware, getNullableInputTypeAtPath, grafast, GrafastArgumentConfig, GrafastExecutionArgs, 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, inhibitOnNull, InputObjectFieldApplyResolver, inputObjectFieldSpec, InputObjectPlans, InputObjectTypeBakedInfo, InputObjectTypeBakedResolver, InputObjectTypeSpec, InterfaceOrUnionPlans, isDev, isExecutableStep, isListCapableStep, isListLikeStep, isModifier, isObjectLikeStep, isPromiseLike, isSafeError, isStep, isUnaryStep, 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, makeDecodeNodeIdRuntime, makeGrafastSchema, Maybe, Modifier, Multistep, multistep, newGrafastFieldConfigBuilder, newInputObjectTypeBuilder, newObjectTypeBuilder, node, NodeIdCodec, nodeIdFromNode, NodeIdHandler, NodeStep, noop, object, objectFieldSpec, ObjectLikeStep, ObjectPlanMeta, ObjectPlans, objectSpec, ObjectStep, ObjectTypeFields, ObjectTypeSpec, OperationPlan, operationPlan, OutputPlanForType, PageInfoCapableStep, partitionByIndex, polymorphicBranch, PolymorphicBranchMatcher, PolymorphicBranchMatchers, PolymorphicBranchStep, PolymorphicData, PolymorphicStep, polymorphicWrap, PromiseOrDirect, proxy, ProxyStep, remapKeys, RemapKeysStep, reverse, reverseArray, ReverseStep, rootValue, SafeError, ScalarPlanResolver, ScalarPlans, Setter, setter, SetterCapable, sideEffect, SideEffectStep, specFromNodeId, Step, stepADependsOnStepB, stepAMayDependOnStepB, StepOptimizeOptions, stepsAreInSamePhase, StepStreamOptions, stringifyPayload, stripAnsi, subscribe, trackedContext, trackedRootValue, trap, TRAP_ERROR, TRAP_ERROR_OR_INHIBITED, TRAP_INHIBITED, TypedEventEmitter, UnaryExecutionValue, UnbatchedStep as UnbatchedExecutableStep, UnbatchedExecutionExtra, UnbatchedStep, UnwrapMultistep, };
+export { __FlagStep, __InputListStep, __InputObjectStep, __InputObjectStepWithDollars, __InputStaticLeafStep, __ItemStep, __ListTransformStep, __TrackedValueStep, __TrackedValueStepWithDollars, __ValueStep, $$bypassGraphQL, $$eventEmitter, $$extensions, $$idempotent, $$inhibit, $$verbatim, AbstractTypePlan, AbstractTypePlanner, access, AccessStep, ActualKeyByDesiredKey, applyInput, ApplyInputStep, applyTransforms, ApplyTransformsStep, arrayOfLength, arraysMatch, assertEdgeCapableStep, assertExecutableStep, assertListCapableStep, assertModifier, assertNotNull, assertPageInfoCapableStep, assertStep, bakedInput, bakedInputRuntime, BakedInputStep, BaseEventMap, BaseGraphQLArguments, BaseGraphQLRootValue, BaseGraphQLVariables, BatchExecutionValue, coalesce, CoalesceStep, condition, ConditionStep, connection, ConnectionCapableStep, ConnectionStep, constant, ConstantStep, context, createObjectAndApplyChildren, DataFromObjectSteps, DataFromStep, debugPlans, DEFAULT_ACCEPT_FLAGS, defaultPlanResolver, defer, Deferred, DeprecatedInputObjectPlan, DeprecatedObjectPlan, each, EdgeCapableStep, EdgeStep, EnumPlan, EnumValueConfig, EnumValueInput, error, ErrorStep, EventCallback, EventMapKey, Step as ExecutableStep, execute, ExecutionDetails, ExecutionDetailsStream, ExecutionEventEmitter, ExecutionEventMap, ExecutionExtra, ExecutionResults, ExecutionResultValue, ExecutionValue, exportAs, exportAsMany, FieldArg, FieldArgs, FieldInfo, FieldPlan, FieldPlanResolver, filter, FilterPlanMemo, first, FirstStep, flagError, get, getEnumValueConfig, getEnumValueConfigs, getGrafastMiddleware, getNullableInputTypeAtPath, grafast, GrafastArgumentConfig, GrafastExecutionArgs, GrafastFieldConfig, GrafastFieldConfigArgumentMap, grafast as grafastGraphql, grafastSync as grafastGraphqlSync, GrafastInputFieldConfig, GrafastInputFieldConfigMap, GrafastInputObjectType, GrafastObjectType, GrafastPlanJSON, grafastPrint, GrafastResultsList, GrafastResultStreamList, GrafastSchemaConfig, GrafastSubscriber, grafastSync, GrafastValuesList, graphqlResolver, GraphQLResolverStep, groupBy, GroupByPlanMemo, inhibitOnNull, InputFieldPlan, InputObjectFieldApplyResolver, inputObjectFieldSpec, InputObjectPlan, InputObjectTypeBakedInfo, InputObjectTypeBakedResolver, InputObjectTypeSpec, inspect, AbstractTypePlan as InterfaceOrUnionPlans, InterfacePlan, isDev, isExecutableStep, isListCapableStep, isListLikeStep, isModifier, isObjectLikeStep, isPromiseLike, isSafeError, isStep, isUnaryStep, 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, makeDecodeNodeIdRuntime, makeGrafastSchema, mapsMatch, Maybe, Modifier, Multistep, multistep, newGrafastFieldConfigBuilder, newInputObjectTypeBuilder, newObjectTypeBuilder, node, NodeIdCodec, nodeIdFromNode, NodeIdHandler, NodeStep, noop, object, ObjectFieldConfig, objectFieldSpec, ObjectLikeStep, ObjectPlan, ObjectPlanMeta, objectSpec, ObjectStep, ObjectTypeFields, ObjectTypeSpec, OperationPlan, operationPlan, PageInfoCapableStep, partitionByIndex, PlanTypeInfo, PromiseOrDirect, proxy, ProxyStep, recordsMatch, remapKeys, RemapKeysStep, reverse, reverseArray, ReverseStep, rootValue, SafeError, ScalarPlan, ScalarPlanResolver, setsMatch, Setter, setter, SetterCapable, sideEffect, SideEffectStep, specFromNodeId, Step, stepADependsOnStepB, stepAMayDependOnStepB, stepAShouldTryAndInlineIntoStepB, StepOptimizeOptions, stepsAreInSamePhase, StepStreamOptions, stringifyPayload, stripAnsi, subscribe, trap, TRAP_ERROR, TRAP_ERROR_OR_INHIBITED, TRAP_INHIBITED, TypedEventEmitter, UnaryExecutionValue, UnbatchedStep as UnbatchedExecutableStep, UnbatchedExecutionExtra, UnbatchedStep, UnionPlan, UnwrapMultistep, };
 export { hookArgs } from "./args.js";
 export { version } from "./version.js";
 /** @deprecated Renamed to 'applyTransforms' */
@@ -81,6 +83,51 @@ declare global {
             assertStep?: ((step: Step) => asserts step is Step) | {
                 new (...args: any[]): Step;
             } | null;
+            /**
+             * Plantime. Given `$stepOrSpecifier`, a step that _hopefully_ represents
+             * relevant data for this object type, return a step that can be used for
+             * planning this object type. Used in the default implementation of
+             * `AbstractTypePlanner.planForType` if that method is not provided.
+             */
+            planType?($stepOrSpecifier: Step): Step;
+        }
+        interface InterfaceTypeExtensions {
+            /**
+             * Takes a step representing this polymorphic position, and returns a
+             * "specifier" step that will be input to planType. If not specified, the
+             * step's own `.toSpecifier()` will be used, if present, otherwise the
+             * step's own `.toRecord()`, and failing that the step itself.
+             */
+            toSpecifier?($step: Step): Step;
+            /**
+             * Plantime. `$stepOrSpecifier` is either a step returned from a field or
+             * list position with an abstract type, or a `__ValueStep` that
+             * represents the combined values of such steps (to prevent unbounded
+             * plan branching). `planType` must then construct a step that
+             * represents the `__typename` related to this given specifier (or `null`
+             * if no match can be found) and a `planForType` method which, when
+             * called, should return the step for the given type.
+             */
+            planType?($stepOrSpecifier: Step, info: PlanTypeInfo): AbstractTypePlanner;
+        }
+        interface UnionTypeExtensions {
+            /**
+             * Takes a step representing this polymorphic position, and returns a
+             * "specifier" step that will be input to planType. If not specified, the
+             * step's own `.toSpecifier()` will be used, if present, otherwise the
+             * step's own `.toRecord()`, and failing that the step itself.
+             */
+            toSpecifier?($step: Step): Step;
+            /**
+             * Plantime. `$stepOrSpecifier` is either a step returned from a field or
+             * list position with an abstract type, or a `__ValueStep` that
+             * represents the combined values of such steps (to prevent unbounded
+             * plan branching). `planType` must then construct a step that
+             * represents the `__typename` related to this given specifier (or `null`
+             * if no match can be found) and a `planForType` method which, when
+             * called, should return the step for the given type.
+             */
+            planType?($stepOrSpecifier: Step, info: PlanTypeInfo): AbstractTypePlanner;
         }
         interface EnumTypeExtensions {
         }
@@ -142,6 +189,21 @@ declare global {
              */
             explain?: boolean | string[];
             timeouts?: GrafastTimeouts;
+            /**
+             * How many planning layers deep do we allow? Should be handled by validation.
+             *
+             * A planning layer can happen due to:
+             *
+             * - A nested selection set
+             * - Planning a field return type
+             * - A list position
+             * - A polymorphic type
+             * - A deferred/streamed response
+             *
+             * These reasons may each cause 1, 2 or 3 planning layers to be added, so this
+             * limit should be set quite high - e.g. 6x the selection set depth.
+             */
+            maxPlanningDepth?: number;
         }
         interface Preset {
             /**
@@ -185,6 +247,12 @@ declare module "graphql" {
     interface GraphQLObjectTypeExtensions<_TSource = any, _TContext = any> {
         grafast?: Grafast.ObjectTypeExtensions;
     }
+    interface GraphQLInterfaceTypeExtensions {
+        grafast?: Grafast.InterfaceTypeExtensions;
+    }
+    interface GraphQLUnionTypeExtensions {
+        grafast?: Grafast.UnionTypeExtensions;
+    }
     interface GraphQLEnumTypeExtensions {
         grafast?: Grafast.EnumTypeExtensions;
     }