grafast 0.1.1-beta.2 → 0.1.1-beta.21

package/dist/engine/executeOutputPlan.d.ts

@@ -1,58 +1,9 @@
-import type { GraphQLError } from "graphql";
 import type { Bucket, RequestTools } from "../bucket.js";
-import type { JSONValue } from "../interfaces.js";
 import type { OutputPlan } from "./OutputPlan.js";
 export type OutputPath = Array<string | number>;
 export interface OutputStream {
     asyncIterable: AsyncIterableIterator<any>;
 }
-/**
- * PayloadRoot handles the root-level of a payload, it's ultimately responsible
- * for sharing the `data`/`errors` with the user. But it also handles the
- * intermediate payloads for stream/defer.
- *
- * A standard GraphQL query/mutation request (one that doesn't use
- * `@stream`/`@defer`) will have just one payload. A standard GraphQL
- * subscription request gets one payload per subscription event.
- *
- * When we mix `@stream` and `@defer` into this, we will require (often quite a
- * lot) more payloads.
- *
- * @internal
- */
-export interface PayloadRoot {
-    /**
-     * Serialization works differently if we're running inside GraphQL. (Namely:
-     * we don't serialize - that's GraphQL's job.)
-     */
-    insideGraphQL: false;
-    /**
-     * The errors that have occurred; these are proper GraphQLErrors and will be
-     * returned directly to clients so they must be complete.
-     */
-    errors: GraphQLError[];
-    /**
-     * Defer queue - we don't start executing these until after the main
-     * payload is completed (to allow for a non-null boundary to abort
-     * execution).
-     */
-    queue: Array<SubsequentPayloadSpec>;
-    /**
-     * Stream queue - we don't start executing these until after the main
-     * payload is completed (to allow for a non-null boundary to abort
-     * execution).
-     */
-    streams: Array<SubsequentStreamSpec>;
-    /**
-     * VERY DANGEROUS. This is _only_ to pass variables through to introspection
-     * selections, it shouldn't be used for anything else.
-     *
-     * @internal
-     * */
-    variables: {
-        [key: string]: any;
-    };
-}
 export interface OutputPlanContext {
     requestContext: RequestTools;
     root: PayloadRoot;
@@ -76,8 +27,4 @@ export interface SubsequentStreamSpec {
     stream: AsyncIterator<any> | Iterator<any>;
     startIndex: number;
 }
-/**
- * @internal
- */
-export declare function executeOutputPlan(ctx: OutputPlanContext, outputPlan: OutputPlan, bucket: Bucket, bucketIndex: number, outputDataAsString: boolean): JSONValue;
 //# sourceMappingURL=executeOutputPlan.d.ts.map

package/dist/engine/executeOutputPlan.js

@@ -1,13 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeOutputPlan = void 0;
+exports.executeOutputPlan = executeOutputPlan;
 const tslib_1 = require("tslib");
+const debug_1 = tslib_1.__importDefault(require("debug"));
 const assert = tslib_1.__importStar(require("../assert.js"));
 const dev_js_1 = require("../dev.js");
+const debug = (0, debug_1.default)("grafast:OutputPlan");
+const debugVerbose = debug.extend("verbose");
 /**
  * @internal
  */
 function executeOutputPlan(ctx, outputPlan, bucket, bucketIndex, outputDataAsString) {
+    if (debugVerbose.enabled) {
+        debugVerbose("Executing %c with data:\n%c", outputPlan, bucket);
+    }
     if (dev_js_1.isDev) {
         assert.strictEqual(bucket.isComplete, true, "Can only process an output plan for a completed bucket");
     }
@@ -17,5 +23,4 @@ function executeOutputPlan(ctx, outputPlan, bucket, bucketIndex, outputDataAsStr
         ? outputPlan.executeString(ctx.root, mutablePath, bucket, bucketIndex)
         : outputPlan.execute(ctx.root, mutablePath, bucket, bucketIndex);
 }
-exports.executeOutputPlan = executeOutputPlan;
 //# sourceMappingURL=executeOutputPlan.js.map

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

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

package/dist/engine/lib/defaultPlanResolver.js

@@ -0,0 +1,11 @@
+"use strict";
+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]);
+};
+exports.defaultPlanResolver = defaultPlanResolver;
+//# sourceMappingURL=defaultPlanResolver.js.map

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

@@ -1,5 +1,7 @@
+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 currentLayerPlan(): LayerPlan;
 export declare function currentPolymorphicPaths(): ReadonlySet<string> | null;
+export declare function isUnaryStep($step: Step): boolean;
 //# sourceMappingURL=withGlobalLayerPlan.d.ts.map

package/dist/engine/lib/withGlobalLayerPlan.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.currentPolymorphicPaths = exports.currentLayerPlan = exports.withGlobalLayerPlan = void 0;
+exports.withGlobalLayerPlan = withGlobalLayerPlan;
+exports.currentLayerPlan = currentLayerPlan;
+exports.currentPolymorphicPaths = currentPolymorphicPaths;
+exports.isUnaryStep = isUnaryStep;
 let globalData_layerPlan = undefined;
 let globalData_polymorphicPaths = undefined;
 function withGlobalLayerPlan(layerPlan, polymorphicPaths, callback, callbackThis, ...callbackArgs) {
@@ -16,7 +19,6 @@ function withGlobalLayerPlan(layerPlan, polymorphicPaths, callback, callbackThis
         globalData_polymorphicPaths = oldPolymorphicPaths;
     }
 }
-exports.withGlobalLayerPlan = withGlobalLayerPlan;
 function currentLayerPlan() {
     if (globalData_layerPlan === undefined) {
         throw new Error(
@@ -25,12 +27,13 @@ function currentLayerPlan() {
     }
     return globalData_layerPlan;
 }
-exports.currentLayerPlan = currentLayerPlan;
 function currentPolymorphicPaths() {
     if (globalData_polymorphicPaths === undefined) {
         throw new Error("GrafastInternalError<b0b05743-8b21-42c6-9b53-925013d88bd1>: currentPolymorphicPaths called out of turn; must only called within a withGlobalLayerPlan callback");
     }
     return globalData_polymorphicPaths;
 }
-exports.currentPolymorphicPaths = currentPolymorphicPaths;
+function isUnaryStep($step) {
+    return $step._isUnary;
+}
 //# sourceMappingURL=withGlobalLayerPlan.js.map

package/dist/engine/lock.d.ts

@@ -0,0 +1,4 @@
+import type { Step } from "..";
+export declare function lock($step: Step): void;
+export declare function unlock($step: Step): boolean;
+//# sourceMappingURL=lock.d.ts.map

package/dist/engine/lock.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$$unlock = void 0;
+exports.lock = lock;
+exports.unlock = unlock;
+/**
+ * Used internally to prevent steps using other steps' optimize/finalize/etc
+ * methods.
+ *
+ * @internal
+ */
+exports.$$unlock = Symbol("unlock");
+function isLocked($step) {
+    return $step[exports.$$unlock] !== undefined;
+}
+function lock($step) {
+    if (!isLocked($step)) {
+        const { optimize, finalize, deduplicate, deduplicatedWith } = $step;
+        if (optimize) {
+            $step.optimize = optimizeLocked;
+        }
+        if (typeof finalize === "function") {
+            $step.finalize = finalizeLocked;
+        }
+        if (deduplicate) {
+            $step.deduplicate = deduplicateLocked;
+        }
+        if (deduplicatedWith) {
+            $step.deduplicatedWith = deduplicatedWithLocked;
+        }
+        $step[exports.$$unlock] = () => {
+            $step[exports.$$unlock] = undefined;
+            if (optimize && $step.optimize !== optimizeLocked) {
+                console.warn(`Warning: ${$step}'s optimize method changed whilst locked`);
+            }
+            else {
+                $step.optimize = optimize;
+            }
+            if (typeof finalize === "function" && $step.finalize !== finalizeLocked) {
+                console.warn(`Warning: ${$step}'s finalize method changed whilst locked`);
+            }
+            else {
+                $step.finalize = finalize;
+            }
+            if (deduplicate && $step.deduplicate !== deduplicateLocked) {
+                console.warn(`Warning: ${$step}'s deduplicate method changed whilst locked`);
+            }
+            else {
+                $step.deduplicate = deduplicate;
+            }
+            if (deduplicatedWith &&
+                $step.deduplicatedWith !== deduplicatedWithLocked) {
+                console.warn(`Warning: ${$step}'s deduplicatedWith method changed whilst locked`);
+            }
+            else {
+                $step.deduplicatedWith = deduplicatedWith;
+            }
+        };
+    }
+}
+function unlock($step) {
+    if (isLocked($step)) {
+        $step[exports.$$unlock]();
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+function optimizeLocked() {
+    throw new Error(`Only Grafast may call a step's optimize method; rather than calling optimize on the steps your class depends on, consider opting in to multiple optimization passes via \`allowMultipleOptimizations\`.`);
+}
+function finalizeLocked() {
+    throw new Error(`Only Grafast may call a step's finalize method; steps should not attempt to interact with other steps during finalize.`);
+}
+function deduplicateLocked() {
+    throw new Error(`Only Grafast may call a step's deduplicate method.`);
+}
+function deduplicatedWithLocked() {
+    throw new Error(`Only Grafast may call a step's deduplicatedWith method.`);
+}
+//# sourceMappingURL=lock.js.map

package/dist/envelop.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useMoreDetailedErrors = exports.useGrafast = void 0;
+const graphile_config_1 = require("graphile-config");
 const execute_js_1 = require("./execute.js");
 const stripAnsi_js_1 = require("./stripAnsi.js");
 const subscribe_js_1 = require("./subscribe.js");
@@ -33,9 +34,9 @@ const useGrafast = (options = {}) => {
         async onExecute(opts) {
             const explainHeaders = opts.args.contextValue?.req?.headers["x-graphql-explain"];
             const explain = processExplain(explainAllowed, explainHeaders);
-            opts.setExecuteFn((args) => (0, execute_js_1.execute)(args, {
+            opts.setExecuteFn((args) => (0, execute_js_1.execute)(args, (0, graphile_config_1.resolvePreset)({
                 grafast: { explain },
-            }));
+            })));
         },
         async onSubscribe(opts) {
             const ctx = opts.args.contextValue;
@@ -43,9 +44,9 @@ const useGrafast = (options = {}) => {
                 ctx?.request?.headers ||
                 ctx?.connectionParams)?.["x-graphql-explain"];
             const explain = processExplain(explainAllowed, explainHeaders);
-            opts.setSubscribeFn(async (args) => (0, subscribe_js_1.subscribe)(args, {
+            opts.setSubscribeFn(async (args) => (0, subscribe_js_1.subscribe)(args, (0, graphile_config_1.resolvePreset)({
                 grafast: { explain },
-            }));
+            })));
         },
     };
 };

package/dist/error.d.ts

@@ -1,62 +1,31 @@
-/// <reference types="node" />
-import type { $$extensions } from "./interfaces.js";
+import type { ExecutionEntryFlags } from "./interfaces.js";
 import { $$safeError } from "./interfaces.js";
+declare const $$flagged: unique symbol;
 /**
- * Internally we wrap errors that occur in a GrafastError; this allows us to do
- * simple `instanceof` checks to see if a value is an actual value or an error.
- * Users should never use this class; it's for internal usage only.
- *
- * @internal
+ * Wrapper for errors to return (rather than throw or reject) from user code.
  */
-export interface GrafastError extends Error {
-    originalError: Error;
-    [$$extensions]?: Record<string, any>;
+export interface FlaggedValue<TValue = any> {
+    [$$flagged]: true;
+    flags: ExecutionEntryFlags;
+    value: TValue;
+    planId: number | null;
+    toString(): string;
 }
-export declare const $$error: unique symbol;
+export declare const $$inhibit: FlaggedValue<null>;
 /**
- * When an error occurs during plan execution we wrap it in a GrafastError so
- * that we can pass it around as a value.  It gets unwrapped and thrown in the
- * grafast resolver.
- *
- * @internal
+ * Used to wrap error values to have Grafast treat them as if they were
+ * thrown/rejected (rather than just regular values).
  */
-export declare const _GrafastError: {
-    new (originalError: Error, planId: number | null): {
-        readonly originalError: Error;
-        extensions: Record<string, any>;
-        [$$error]: boolean;
-        name: string;
-        message: string;
-        stack?: string | undefined;
-        cause?: unknown;
-    };
-    captureStackTrace(targetObject: object, constructorOpt?: Function | undefined): void;
-    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
-    stackTraceLimit: number;
-};
-/**
- * DO NOT ALLOW CONSTRUCTION OF ERRORS OUTSIDE OF THIS MODULE!
- *
- * @internal
- */
-export declare function newGrafastError(error: Error, planId: number | null): {
-    readonly originalError: Error;
-    extensions: Record<string, any>;
-    [$$error]: boolean;
-    name: string;
-    message: string;
-    stack?: string | undefined;
-    cause?: unknown;
-};
-/**
- * Is the given value a GrafastError? This is the only public API that people
- * should use for looking at GrafastErrors.
- */
-export declare function isGrafastError(value: any): value is GrafastError;
+export declare function flagError<TError extends Error = Error>(value: TError, planId?: number | null): FlaggedValue<TError>;
 export declare class SafeError<TExtensions extends Record<string, any> | undefined = Record<string, any> | undefined> extends Error {
     extensions: TExtensions;
+    static $$export: {
+        moduleName: string;
+        exportName: string;
+    };
     [$$safeError]: boolean;
     constructor(message: string, extensions?: TExtensions, errorOptions?: ErrorOptions);
 }
 export declare function isSafeError(error: Error): error is SafeError;
+export {};
 //# sourceMappingURL=error.d.ts.map

package/dist/error.js

@@ -1,56 +1,68 @@
 "use strict";
-var _a, _b;
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isSafeError = exports.SafeError = exports.isGrafastError = exports.newGrafastError = exports._GrafastError = exports.$$error = void 0;
+exports.SafeError = exports.$$inhibit = void 0;
+exports.flagError = flagError;
+exports.isFlaggedValue = isFlaggedValue;
+exports.isSafeError = isSafeError;
+const dev_js_1 = require("./dev.js");
+const inspect_js_1 = require("./inspect.js");
 const interfaces_js_1 = require("./interfaces.js");
-exports.$$error = Symbol("isGrafastError");
-// IMPORTANT: this WILL NOT WORK when compiled down to ES5. It requires ES6+
-// native class support.
-/**
- * When an error occurs during plan execution we wrap it in a GrafastError so
- * that we can pass it around as a value.  It gets unwrapped and thrown in the
- * grafast resolver.
- *
- * @internal
- */
-const _GrafastError = class GrafastError extends Error {
-    static { _a = exports.$$error; }
-    constructor(originalError, planId) {
-        if (originalError instanceof exports._GrafastError) {
-            throw new Error("GrafastInternalError<62505509-8b21-4ef7-80f5-d0f99873174b>: attempted to wrap a GrafastError with a GrafastError.");
+const $$flagged = Symbol("grafastFlaggedValue");
+function flaggedValueToString() {
+    if (this.flags & interfaces_js_1.FLAG_ERROR && this.value instanceof Error) {
+        return String(this.value);
+    }
+    else if (this.flags & interfaces_js_1.FLAG_INHIBITED && this.value === null) {
+        return "INHIBIT";
+    }
+    else {
+        return `${this.flags}/${(0, inspect_js_1.inspect)(this.value)}`;
+    }
+}
+function flaggedValue(flags, value, planId) {
+    if (dev_js_1.isDev) {
+        if (value === null && !(flags & interfaces_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)) {
+            throw new Error(`flaggedValue called with null, but not flagged as inhibited.`);
         }
-        const message = originalError?.message;
-        super(message);
-        this[_a] = true;
-        Object.setPrototypeOf(this, GrafastError.prototype);
-        this.originalError = originalError;
-        this.extensions = { grafast: { planId } };
     }
-};
-exports._GrafastError = _GrafastError;
+    return {
+        [$$flagged]: true,
+        flags,
+        value,
+        planId,
+        toString: flaggedValueToString,
+    };
+}
+exports.$$inhibit = flaggedValue(interfaces_js_1.FLAG_NULL | interfaces_js_1.FLAG_INHIBITED, null, null);
 /**
- * DO NOT ALLOW CONSTRUCTION OF ERRORS OUTSIDE OF THIS MODULE!
- *
- * @internal
+ * Used to wrap error values to have Grafast treat them as if they were
+ * thrown/rejected (rather than just regular values).
  */
-function newGrafastError(error, planId) {
-    return new exports._GrafastError(error, planId);
+function flagError(value, planId = null) {
+    return flaggedValue(interfaces_js_1.FLAG_ERROR, value, planId);
 }
-exports.newGrafastError = newGrafastError;
 /**
- * Is the given value a GrafastError? This is the only public API that people
- * should use for looking at GrafastErrors.
+ * Is this a flagged value?
+ *
+ * @internal
  */
-function isGrafastError(value) {
-    return typeof value === "object" && value !== null && exports.$$error in value;
+function isFlaggedValue(value) {
+    return Object.hasOwn(value, $$flagged);
 }
-exports.isGrafastError = isGrafastError;
 class SafeError extends Error {
-    static { _b = interfaces_js_1.$$safeError; }
+    static { _a = interfaces_js_1.$$safeError; }
+    static { this.$$export = {
+        moduleName: "grafast",
+        exportName: "SafeError",
+    }; }
     constructor(message, extensions = undefined, errorOptions) {
         super(message, errorOptions);
         this.extensions = extensions;
-        this[_b] = true;
+        this[_a] = true;
         Object.setPrototypeOf(this, SafeError.prototype);
     }
 }
@@ -58,5 +70,4 @@ exports.SafeError = SafeError;
 function isSafeError(error) {
     return error[interfaces_js_1.$$safeError];
 }
-exports.isSafeError = isSafeError;
 //# sourceMappingURL=error.js.map

package/dist/establishOperationPlan.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.establishOperationPlan = void 0;
+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"));
@@ -14,7 +14,7 @@ const debug = (0, debug_1.default)("grafast:establishOperationPlan");
 const TIMEOUT_TIMEOUT = (typeof process !== "undefined" &&
     typeof process.env.GRAFAST_TIMEOUT_VALIDITY_MS === "string"
     ? parseInt(process.env.GRAFAST_TIMEOUT_VALIDITY_MS, 10)
-    : null) || 60000;
+    : null) || 60_000;
 // OPTIMIZE: we should consider increasing the timeout once the process has been
 // running a while (since the JIT should have kicked in) - we could even use
 // `setTimeout` to trigger it after certain amount of time elapsed.
@@ -50,7 +50,7 @@ const assertFragmentsMatch = !dev_js_1.isDev ? dev_js_1.noop : reallyAssertFragm
  * @remarks Due to the optimisation in `establishOperationPlan`, the schema, document
  * and operationName checks have already been performed.
  */
-function isOperationPlanCompatible(operationPlan, variableValues, context, rootValue) {
+function isOperationPlanResultCompatible(operationPlan, variableValues, context, rootValue) {
     const { variableValuesConstraints, contextConstraints, rootValueConstraints, } = operationPlan;
     if (!(0, constraints_js_1.matchesConstraints)(variableValuesConstraints, variableValues)) {
         return false;
@@ -84,49 +84,54 @@ function establishOperationPlan(schema, operation, fragments, variableValues, co
         let linkedItem = cache.possibleOperationPlans;
         while (linkedItem) {
             const value = linkedItem.value;
-            if (value instanceof index_js_1.SafeError) {
-                if (value.extensions?.[interfaces_js_1.$$timeout] != null) {
-                    if (value.extensions[interfaces_js_1.$$ts] < timeSource_js_1.timeSource.now() - TIMEOUT_TIMEOUT) {
-                        // Remove this out of date timeout
-                        linkedItem = linkedItem.next;
-                        if (previousItem !== null) {
-                            previousItem.next = linkedItem;
+            if (isOperationPlanResultCompatible(value, variableValues, context, rootValue)) {
+                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) {
+                                // Remove this out of date timeout
+                                linkedItem = linkedItem.next;
+                                if (previousItem !== null) {
+                                    previousItem.next = linkedItem;
+                                }
+                                else {
+                                    cache.possibleOperationPlans = linkedItem;
+                                }
+                                continue;
+                            }
+                            if (planningTimeout !== null &&
+                                error.extensions[interfaces_js_1.$$timeout] >= planningTimeout) {
+                                // It was a timeout error - do not retry
+                                throw error;
+                            }
+                            else {
+                                // That's Not My Timeout, let's try again.
+                            }
                         }
                         else {
-                            cache.possibleOperationPlans = linkedItem;
+                            // Not a timeout error - this will always fail in the same way?
+                            throw error;
                         }
-                        continue;
-                    }
-                    if (planningTimeout !== null &&
-                        value.extensions[interfaces_js_1.$$timeout] >= planningTimeout) {
-                        // It was a timeout error - do not retry
-                        throw value;
                     }
                     else {
-                        // That's Not My Timeout, let's try again.
+                        // Not a timeout error - this will always fail in the same way?
+                        throw error;
                     }
                 }
                 else {
-                    // Not a timeout error - this will always fail in the same way?
-                    throw value;
-                }
-            }
-            else if (value instanceof Error) {
-                // Not a timeout error - this will always fail in the same way?
-                throw value;
-            }
-            else if (isOperationPlanCompatible(value, variableValues, context, rootValue)) {
-                // Hoist to top of linked list
-                if (previousItem !== null) {
-                    // Remove linkedItem from existing chain
-                    previousItem.next = linkedItem.next;
-                    // Add rest of chain after linkedItem
-                    linkedItem.next = cache.possibleOperationPlans;
-                    // linkedItem is now head of chain
-                    cache.possibleOperationPlans = linkedItem;
+                    // Hoist to top of linked list
+                    if (previousItem !== null) {
+                        // Remove linkedItem from existing chain
+                        previousItem.next = linkedItem.next;
+                        // Add rest of chain after linkedItem
+                        linkedItem.next = cache.possibleOperationPlans;
+                        // linkedItem is now head of chain
+                        cache.possibleOperationPlans = linkedItem;
+                    }
+                    // We found a suitable OperationPlan - use that!
+                    return operationPlan;
                 }
-                // We found a suitable OperationPlan - use that!
-                return value;
             }
             count++;
             lastButOneItem = previousItem;
@@ -137,8 +142,11 @@ function establishOperationPlan(schema, operation, fragments, variableValues, co
     // No suitable OperationPlan found, time to make one.
     let operationPlan;
     let error;
+    const variableValuesConstraints = [];
+    const contextConstraints = [];
+    const rootValueConstraints = [];
     try {
-        operationPlan = new index_js_1.OperationPlan(schema, operation, fragments, variableValues, context, rootValue, planningTimeout);
+        operationPlan = new index_js_1.OperationPlan(schema, operation, fragments, variableValuesConstraints, variableValues, contextConstraints, context, rootValueConstraints, rootValue, planningTimeout);
     }
     catch (e) {
         error = e;
@@ -153,11 +161,19 @@ function establishOperationPlan(schema, operation, fragments, variableValues, co
         });
         schema.extensions.grafast[interfaces_js_1.$$cacheByOperation] = cacheByOperation;
     }
-    const operationPlanOrError = operationPlan ?? error;
+    const establishOperationPlanResult = {
+        variableValuesConstraints,
+        contextConstraints,
+        rootValueConstraints,
+        ...(operationPlan ? { operationPlan } : { error: error }),
+    };
     if (!cache) {
         cache = {
             fragments,
-            possibleOperationPlans: { value: operationPlanOrError, next: null },
+            possibleOperationPlans: {
+                value: establishOperationPlanResult,
+                next: null,
+            },
         };
         cacheByOperation.set(operation, cache);
     }
@@ -171,7 +187,7 @@ function establishOperationPlan(schema, operation, fragments, variableValues, co
         }
         // Add new operationPlan to top of the linked list.
         cache.possibleOperationPlans = {
-            value: operationPlanOrError,
+            value: establishOperationPlanResult,
             next: cache.possibleOperationPlans,
         };
     }
@@ -182,5 +198,4 @@ function establishOperationPlan(schema, operation, fragments, variableValues, co
         return operationPlan;
     }
 }
-exports.establishOperationPlan = establishOperationPlan;
 //# sourceMappingURL=establishOperationPlan.js.map

package/dist/execute.d.ts

@@ -1,13 +1,14 @@
 import type { AsyncExecutionResult, ExecutionArgs, ExecutionResult } from "graphql";
 import type { PromiseOrValue } from "graphql/jsutils/PromiseOrValue";
+import type { GrafastExecutionArgs } from "./interfaces.js";
 /**
- * Used by `execute` and `subscribe`.
- * @internal
+ * @deprecated Second and third parameters should be passed as part of args,
+ * specifically `resolvedPreset` and `outputDataAsString`.
  */
-export declare function withGrafastArgs(args: ExecutionArgs, resolvedPreset: GraphileConfig.ResolvedPreset, outputDataAsString: boolean): PromiseOrValue<ExecutionResult | AsyncGenerator<AsyncExecutionResult, void, void>>;
+export declare function execute(args: ExecutionArgs, resolvedPreset: GraphileConfig.ResolvedPreset | undefined, outputDataAsString?: boolean): PromiseOrValue<ExecutionResult | AsyncGenerator<AsyncExecutionResult, void, undefined>>;
 /**
  * Use this instead of GraphQL.js' execute method and we'll automatically
  * run grafastPrepare for you and handle the result.
  */
-export declare function execute(args: ExecutionArgs, resolvedPreset?: GraphileConfig.ResolvedPreset, outputDataAsString?: boolean): PromiseOrValue<ExecutionResult | AsyncGenerator<AsyncExecutionResult, void, undefined>>;
+export declare function execute(args: GrafastExecutionArgs): PromiseOrValue<ExecutionResult | AsyncGenerator<AsyncExecutionResult, void, undefined>>;
 //# sourceMappingURL=execute.d.ts.map