grafast 0.1.1-beta.5 → 0.1.1-beta.6

package/dist/dev.js

@@ -4,7 +4,24 @@ exports.noop = exports.isDev = void 0;
 /**
  * @internal
  */
-exports.isDev = typeof process !== "undefined" && process.env.GRAPHILE_ENV === "development";
+const graphileEnv = typeof process !== "undefined" ? process.env.GRAPHILE_ENV : undefined;
+const nodeEnv = typeof process !== "undefined" ? process.env.NODE_ENV : undefined;
+/**
+ * @internal
+ */
+exports.isDev = graphileEnv !== undefined
+    ? graphileEnv === "development" || graphileEnv === "test"
+    : nodeEnv === "development" || nodeEnv === "test";
 function noop() { }
 exports.noop = noop;
+if (typeof process !== "undefined" &&
+    typeof graphileEnv === "undefined" &&
+    typeof nodeEnv === "undefined") {
+    console.warn(`The GRAPHILE_ENV environmental variable is not set; Grafast will run in production mode. In your development environments, it's recommended that you set \`GRAPHILE_ENV=development\` to opt in to additional checks that will provide guidance and help you to catch issues in your code earlier, and other changes such as formatting to improve your development experience.`);
+}
+else if (exports.isDev) {
+    console.warn(`Grafast is running in development mode due to \`${graphileEnv !== undefined
+        ? `GRAPHILE_ENV=${graphileEnv}`
+        : `NODE_ENV=${nodeEnv}`}\`; this is recommended for development environments (and strongly discouraged in production), but will impact on performance - in particular, planning will be significantly more expensive.`);
+}
 //# sourceMappingURL=dev.js.map

package/dist/engine/OperationPlan.js

@@ -21,6 +21,7 @@ const timeSource_js_1 = require("../timeSource.js");
 const utils_js_1 = require("../utils.js");
 const LayerPlan_js_1 = require("./LayerPlan.js");
 const withGlobalLayerPlan_js_1 = require("./lib/withGlobalLayerPlan.js");
+const lock_js_1 = require("./lock.js");
 const OutputPlan_js_1 = require("./OutputPlan.js");
 const StepTracker_js_1 = require("./StepTracker.js");
 const atpe = typeof process !== "undefined" && process.env.ALWAYS_THROW_PLANNING_ERRORS;
@@ -49,9 +50,6 @@ const EMPTY_ARRAY = Object.freeze([]);
 exports.POLYMORPHIC_ROOT_PATH = null;
 exports.POLYMORPHIC_ROOT_PATHS = null;
 Object.freeze(exports.POLYMORPHIC_ROOT_PATHS);
-/** In development we might run additional checks */
-const isDev = typeof process !== "undefined" &&
-    (process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test");
 /** How many times will we try re-optimizing before giving up */
 const MAX_OPTIMIZATION_LOOPS = 10;
 const REASON_ROOT = Object.freeze({ type: "root" });
@@ -88,7 +86,7 @@ class OperationPlan {
         /**
          * Gets updated as we work our way through the plan, useful for making errors more helpful.
          */
-        this.loc = isDev
+        this.loc = index_js_1.isDev
             ? []
             : null /* forbid loc in production */;
         this.modifierStepCount = 0;
@@ -117,7 +115,7 @@ class OperationPlan {
         this.laps = [];
         this.optimizeMeta = new Map();
         /** @internal Use plan.getStep(id) instead. */
-        this.getStep = isDev
+        this.getStep = index_js_1.isDev
             ? (id, requestingStep) => {
                 if (!["plan", "validate", "optimize"].includes(this.phase)) {
                     throw new Error(`Getting a step during the '${this.phase}' phase is forbidden - please do so before or during the optimize phase.`);
@@ -191,7 +189,7 @@ class OperationPlan {
         this.hoistSteps();
         this.checkTimeout();
         this.lap("hoistSteps", "planOperation");
-        if (isDev) {
+        if (index_js_1.isDev) {
             this.phase = "validate";
             // Helpfully check steps don't do forbidden things.
             this.validateSteps();
@@ -785,7 +783,7 @@ class OperationPlan {
         if (this.loc !== null) {
             this.loc.push(`planSelectionSet(${objectType.name} @ ${outputPlan.layerPlan.id} @ ${path.join(".")} @ ${polymorphicPath ?? ""})`);
         }
-        if (isDev) {
+        if (index_js_1.isDev) {
             assertObjectType(objectType);
         }
         const groupedFieldSet = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(outputPlan.layerPlan, polymorphicPaths, graphqlCollectFields_js_1.graphqlCollectFields, null, this, parentStep.id, objectType, selections, isMutation);
@@ -847,7 +845,7 @@ class OperationPlan {
             });
         }
         else if (isObjectType(nullableFieldType)) {
-            if (isDev) {
+            if (index_js_1.isDev) {
                 // Check that the plan we're dealing with is the one the user declared
                 /** Either an assertion function or a step class */
                 const stepAssertion = nullableFieldType.extensions?.grafast?.assertStep;
@@ -1159,7 +1157,7 @@ class OperationPlan {
         const trackedArgumentValues = Object.create(null);
         for (const argumentDefinition of argumentDefinitions) {
             const argumentName = argumentDefinition.name;
-            if (isDev && trackedArgumentValues[argumentName]) {
+            if (index_js_1.isDev && trackedArgumentValues[argumentName]) {
                 throw new index_js_1.SafeError(`Argument name '${argumentName}' seen twice; aborting.`);
             }
             const argumentType = argumentDefinition.type;
@@ -1309,6 +1307,8 @@ class OperationPlan {
      * @internal
      */
     processSteps(actionDescription, order, isReadonly, callback) {
+        if (index_js_1.isDev)
+            this.stepTracker.lockNewSteps();
         const previousStepCount = this.stepTracker.stepCount;
         const processed = new Set();
         for (let i = 0; i < this.stepTracker.stepCount; i++) {
@@ -1317,7 +1317,7 @@ class OperationPlan {
             if (!step || step.id !== i || processed.has(step))
                 continue;
             const resultStep = this.processStep(actionDescription, order, isReadonly, callback, processed, step);
-            if (isDev) {
+            if (index_js_1.isDev) {
                 const plansAdded = this.stepTracker.stepCount - previousStepCount;
                 // NOTE: whilst processing steps new steps may be added, thus we must loop
                 // ascending and we must re-evaluate this.stepTracker.stepCount on each loop
@@ -1326,8 +1326,13 @@ class OperationPlan {
                     throw new Error(`Whilst processing steps as part of ${actionDescription}Plans, ${plansAdded} new steps have been created... That seems like it's likely a bug in the relevant method of one of your steps. The last plan processed was ${resultStep}`);
                 }
             }
-            if (isReadonly && this.stepTracker.stepCount > previousStepCount) {
-                throwNoNewStepsError(this, actionDescription, step, previousStepCount, "Creating steps in isReadonly mode is forbidden");
+            if ((isReadonly || index_js_1.isDev) &&
+                this.stepTracker.stepCount > previousStepCount) {
+                if (isReadonly) {
+                    throwNoNewStepsError(this, actionDescription, step, previousStepCount, "Creating steps in isReadonly mode is forbidden");
+                }
+                if (index_js_1.isDev)
+                    this.stepTracker.lockNewSteps();
             }
         }
         if (!isReadonly &&
@@ -1803,12 +1808,15 @@ class OperationPlan {
         // planned, which the step class may want to acknowledge by locking certain
         // facets of its functionality (such as adding filters). We'll simplify its
         // work though by giving it an empty array to filter.
+        const wasLocked = index_js_1.isDev && (0, lock_js_1.unlock)(step);
         const equivalentSteps = step.deduplicate(peers);
+        if (wasLocked)
+            (0, lock_js_1.lock)(step);
         if (equivalentSteps.length === 0) {
             // No other equivalents
             return null;
         }
-        if (isDev) {
+        if (index_js_1.isDev) {
             if (!equivalentSteps.every((replacementStep) => peers.includes(replacementStep))) {
                 throw new Error(`deduplicatePlan error: '${step}.deduplicate' may only return steps from its peers peers (peers = ${peers}), but it returned ${equivalentSteps}. This is currently forbidden because it could cause confusion during the optimization process, instead apply this change in 'optimize', or make sure that any child selections aren't applied until the optimize/finalize phase so that no mapping is required during deduplicate.`);
             }
@@ -1851,12 +1859,18 @@ class OperationPlan {
         }
         // Give the steps a chance to pass their responsibilities to the winner.
         if (winner !== step) {
+            const wasLocked = index_js_1.isDev && (0, lock_js_1.unlock)(step);
             step.deduplicatedWith?.(winner);
+            if (wasLocked)
+                (0, lock_js_1.lock)(step);
             this.stepTracker.replaceStep(step, winner);
         }
         for (const target of equivalentSteps) {
             if (winner !== target) {
+                const wasLocked = index_js_1.isDev && (0, lock_js_1.unlock)(target);
                 target.deduplicatedWith?.(winner);
+                if (wasLocked)
+                    (0, lock_js_1.lock)(target);
                 this.stepTracker.replaceStep(target, winner);
             }
         }
@@ -2000,10 +2014,13 @@ class OperationPlan {
                 this.optimizeMeta.set(step.optimizeMetaKey, meta);
             }
         }
+        const wasLocked = index_js_1.isDev && (0, lock_js_1.unlock)(step);
         const replacementStep = step.optimize({
             ...stepOptions,
             meta,
         });
+        if (wasLocked)
+            (0, lock_js_1.lock)(step);
         if (!replacementStep) {
             throw new Error(`Bug in ${step}'s class: the 'optimize' method must return a step. Hint: did you forget 'return this;'?`);
         }
@@ -2054,9 +2071,12 @@ class OperationPlan {
         const initialStepCount = this.stepTracker.stepCount;
         assert.strictEqual(this.modifierSteps.length, 0, "No modifier steps expected when performing finalizeSteps");
         for (const step of this.stepTracker.activeSteps) {
+            const wasLocked = index_js_1.isDev && (0, lock_js_1.unlock)(step);
             step.finalize();
+            if (wasLocked)
+                (0, lock_js_1.lock)(step);
             (0, step_js_1.assertFinalized)(step);
-            if (isDev && this.stepTracker.stepCount !== initialStepCount) {
+            if (index_js_1.isDev && this.stepTracker.stepCount !== initialStepCount) {
                 throw new Error(`When calling ${step}.finalize() a new plan was created; this is forbidden!`);
             }
         }
@@ -2072,7 +2092,7 @@ class OperationPlan {
                 if (currentLayerPlan.copyStepIds.includes(dep.id)) {
                     break;
                 }
-                if (isDev && this.stepTracker.getStepById(dep.id) !== dep) {
+                if (index_js_1.isDev && this.stepTracker.getStepById(dep.id) !== dep) {
                     throw new Error(`GrafastInternalError<b291b110-396a-4c9c-814a-5466af3c50e8>: Plan mismatch; are we using a replaced step? Step ID: ${dep.id}; step: ${dep}; stepById: ${this.stepTracker.getStepById(dep.id)}`);
                 }
                 currentLayerPlan.copyStepIds.push(dep.id);

package/dist/engine/StepTracker.js

@@ -4,6 +4,7 @@ exports.StepTracker = void 0;
 const dev_js_1 = require("../dev.js");
 const interfaces_js_1 = require("../interfaces.js");
 const utils_js_1 = require("../utils.js");
+const lock_js_1 = require("./lock.js");
 /**
  * We want everything else to treat things like `dependencies` as read only,
  * however we ourselves want to be able to write to them, so we can use
@@ -29,6 +30,8 @@ class StepTracker {
         /** @internal */
         this.stepCount = 0;
         /** @internal */
+        this.lockedStepCount = 0;
+        /** @internal */
         this.activeSteps = new Set();
         /** @internal */
         this.stepById = [];
@@ -520,6 +523,17 @@ class StepTracker {
     removeStepFromItsLayerPlan(step) {
         step.layerPlan.stepsByConstructor.get(step.constructor).delete(step);
     }
+    lockNewSteps() {
+        if (!dev_js_1.isDev)
+            return;
+        for (let i = this.lockedStepCount; i < this.stepCount; i++) {
+            const step = this.getStepById(i, true);
+            if (step && step.id === i) {
+                (0, lock_js_1.lock)(step);
+            }
+        }
+        this.lockedStepCount = this.stepCount;
+    }
 }
 exports.StepTracker = StepTracker;
 //# sourceMappingURL=StepTracker.js.map

package/dist/engine/lock.d.ts

@@ -0,0 +1,4 @@
+import type { ExecutableStep } from "..";
+export declare function lock($step: ExecutableStep): void;
+export declare function unlock($step: ExecutableStep): 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 = exports.lock = exports.$$unlock = void 0;
+/**
+ * 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;
+            }
+        };
+    }
+}
+exports.lock = lock;
+function unlock($step) {
+    if (isLocked($step)) {
+        $step[exports.$$unlock]();
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+exports.unlock = unlock;
+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/execute.js

@@ -4,18 +4,18 @@ exports.execute = exports.withGrafastArgs = void 0;
 const tslib_1 = require("tslib");
 const eventemitter3_1 = tslib_1.__importDefault(require("eventemitter3"));
 const config_js_1 = require("./config.js");
+const dev_js_1 = require("./dev.js");
 const inspect_js_1 = require("./inspect.js");
 const interfaces_js_1 = require("./interfaces.js");
 const prepare_js_1 = require("./prepare.js");
 const utils_js_1 = require("./utils.js");
-const isDev = typeof process !== "undefined" && process.env.NODE_ENV === "development";
 /**
  * Used by `execute` and `subscribe`.
  * @internal
  */
 function withGrafastArgs(args, resolvedPreset, outputDataAsString) {
     const options = resolvedPreset?.grafast;
-    if (isDev) {
+    if (dev_js_1.isDev) {
         if (args.rootValue != null &&
             (typeof args.rootValue !== "object" ||
                 Object.keys(args.rootValue).length > 0)) {

package/dist/makeGrafastSchema.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeGrafastSchema = void 0;
 const tslib_1 = require("tslib");
 const graphql = tslib_1.__importStar(require("graphql"));
+const utils_js_1 = require("./utils.js");
 const { buildASTSchema, isEnumType, isInputObjectType, isInterfaceType, isObjectType, isScalarType, isUnionType, parse, } = graphql;
 /**
  * Takes a GraphQL schema definition in Interface Definition Language (IDL/SDL)
@@ -28,6 +29,7 @@ function makeGrafastSchema(details) {
             const fields = type.getFields();
             for (const [fieldName, fieldSpec] of Object.entries(objSpec)) {
                 if (fieldName === "__assertStep") {
+                    (0, utils_js_1.exportNameHint)(fieldSpec, `${typeName}_assertStep`);
                     type.extensions.grafast = { assertStep: fieldSpec };
                     continue;
                 }
@@ -40,6 +42,7 @@ function makeGrafastSchema(details) {
                     continue;
                 }
                 if (typeof fieldSpec === "function") {
+                    (0, utils_js_1.exportNameHint)(fieldSpec, `${typeName}_${fieldName}_plan`);
                     // it's a plan
                     field.extensions.grafast = {
                         plan: fieldSpec,
@@ -50,15 +53,19 @@ function makeGrafastSchema(details) {
                     const grafastExtensions = Object.create(null);
                     field.extensions.grafast = grafastExtensions;
                     if (typeof fieldSpec.resolve === "function") {
+                        (0, utils_js_1.exportNameHint)(fieldSpec.resolve, `${typeName}_${fieldName}_resolve`);
                         field.resolve = fieldSpec.resolve;
                     }
                     if (typeof fieldSpec.subscribe === "function") {
+                        (0, utils_js_1.exportNameHint)(fieldSpec.subscribe, `${typeName}_${fieldName}_subscribe`);
                         field.subscribe = fieldSpec.subscribe;
                     }
                     if (typeof fieldSpec.plan === "function") {
+                        (0, utils_js_1.exportNameHint)(fieldSpec.plan, `${typeName}_${fieldName}_plan`);
                         grafastExtensions.plan = fieldSpec.plan;
                     }
                     if (typeof fieldSpec.subscribePlan === "function") {
+                        (0, utils_js_1.exportNameHint)(fieldSpec.subscribePlan, `${typeName}_${fieldName}_subscribePlan`);
                         grafastExtensions.subscribePlan = fieldSpec.subscribePlan;
                     }
                     if (typeof fieldSpec.args === "object" && fieldSpec.args != null) {
@@ -73,6 +80,10 @@ function makeGrafastSchema(details) {
                                 throw new Error(`Invalid configuration for plans.${typeName}.${fieldName}.args.${argName} - saw a function, but expected an object with 'inputPlan' (optional) and 'applyPlan' (optional) plans`);
                             }
                             else {
+                                if (argSpec) {
+                                    (0, utils_js_1.exportNameHint)(argSpec.applyPlan, `${typeName}_${fieldName}_${argName}_applyPlan`);
+                                    (0, utils_js_1.exportNameHint)(argSpec.inputPlan, `${typeName}_${fieldName}_${argName}_inputPlan`);
+                                }
                                 const grafastExtensions = Object.create(null);
                                 arg.extensions.grafast = grafastExtensions;
                                 Object.assign(grafastExtensions, argSpec);
@@ -98,6 +109,10 @@ function makeGrafastSchema(details) {
                     throw new Error(`Expected input object type '${typeName}' field '${fieldName}' to be an object, but found a function. We don't know if this should be the 'inputPlan' or 'applyPlan' - please supply an object.`);
                 }
                 else {
+                    if (fieldSpec) {
+                        (0, utils_js_1.exportNameHint)(fieldSpec.inputPlan, `${typeName}_${fieldName}_inputPlan`);
+                        (0, utils_js_1.exportNameHint)(fieldSpec.applyPlan, `${typeName}_${fieldName}_applyPlan`);
+                    }
                     // it's a spec
                     const grafastExtensions = Object.create(null);
                     field.extensions.grafast = grafastExtensions;
@@ -111,6 +126,7 @@ function makeGrafastSchema(details) {
             }
             const polySpec = spec;
             if (polySpec.__resolveType) {
+                (0, utils_js_1.exportNameHint)(polySpec.__resolveType, `${typeName}_resolveType`);
                 type.resolveType = polySpec.__resolveType;
             }
         }
@@ -120,15 +136,19 @@ function makeGrafastSchema(details) {
             }
             const scalarSpec = spec;
             if (typeof scalarSpec.serialize === "function") {
+                (0, utils_js_1.exportNameHint)(scalarSpec.serialize, `${typeName}_serialize`);
                 type.serialize = scalarSpec.serialize;
             }
             if (typeof scalarSpec.parseValue === "function") {
+                (0, utils_js_1.exportNameHint)(scalarSpec.parseValue, `${typeName}_parseValue`);
                 type.parseValue = scalarSpec.parseValue;
             }
             if (typeof scalarSpec.parseLiteral === "function") {
+                (0, utils_js_1.exportNameHint)(scalarSpec.parseLiteral, `${typeName}_parseLiteral`);
                 type.parseLiteral = scalarSpec.parseLiteral;
             }
             if (typeof scalarSpec.plan === "function") {
+                (0, utils_js_1.exportNameHint)(scalarSpec.plan, `${typeName}_plan`);
                 type.extensions.grafast = { plan: scalarSpec.plan };
             }
         }
@@ -144,6 +164,7 @@ function makeGrafastSchema(details) {
                     continue;
                 }
                 if (typeof enumValueSpec === "function") {
+                    (0, utils_js_1.exportNameHint)(enumValueSpec, `${typeName}_${enumValueName}_applyPlan`);
                     // It's a plan
                     enumValue.extensions.grafast = {
                         applyPlan: enumValueSpec,
@@ -152,6 +173,7 @@ function makeGrafastSchema(details) {
                 else if (typeof enumValueSpec === "object" && enumValueSpec != null) {
                     // It's a full spec
                     if (enumValueSpec.applyPlan) {
+                        (0, utils_js_1.exportNameHint)(enumValueSpec.applyPlan, `${typeName}_${enumValueName}_applyPlan`);
                         enumValue.extensions.grafast = {
                             applyPlan: enumValueSpec.applyPlan,
                         };

package/dist/step.d.ts

@@ -106,7 +106,7 @@ export declare class ExecutableStep<TData = any> extends BaseStep {
     constructor();
     protected withMyLayerPlan<T>(callback: () => T): T;
     protected getStep(id: number): ExecutableStep;
-    getDep(depId: number): ExecutableStep;
+    protected getDep(depId: number): ExecutableStep;
     /**
      * Like getDep, except it skips over __ItemStep and similar steps to get to
      * where the parent really is.

package/dist/step.js

@@ -1,5 +1,5 @@
 "use strict";
-var _a;
+var _a, _b;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.assertListCapableStep = exports.isListCapableStep = exports.assertModifierStep = exports.isModifierStep = exports.ModifierStep = exports.isPolymorphicStep = exports.isStreamableStep = exports.isListLikeStep = exports.isObjectLikeStep = exports.isUnbatchedExecutableStep = exports.assertExecutableStep = exports.isExecutableStep = exports.UnbatchedExecutableStep = exports.ExecutableStep = exports.BaseStep = exports.assertFinalized = exports.$$noExec = exports.$$deepDepSkip = void 0;
 const tslib_1 = require("tslib");
@@ -7,6 +7,7 @@ const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const tamedevil_1 = tslib_1.__importDefault(require("tamedevil"));
 const dev_js_1 = require("./dev.js");
 const withGlobalLayerPlan_js_1 = require("./engine/lib/withGlobalLayerPlan.js");
+const lock_js_1 = require("./engine/lock.js");
 const global_js_1 = require("./global.js");
 const inspect_js_1 = require("./inspect.js");
 const interfaces_js_1 = require("./interfaces.js");
@@ -97,8 +98,11 @@ exports.BaseStep = BaseStep;
  * they must be able to execute to return values.
  */
 class ExecutableStep extends BaseStep {
+    static { _b = lock_js_1.$$unlock; }
     constructor() {
         super();
+        /** @internal */
+        this[_b] = undefined;
         this.dependencies = [];
         this.dependents = [];
         this.isOptimized = false;

package/dist/steps/__item.d.ts

@@ -17,6 +17,7 @@ export declare class __ItemStep<TData> extends UnbatchedExecutableStep<TData> {
     constructor(parentPlan: ExecutableStep<TData> | ExecutableStep<TData[]>, depth?: number);
     toStringMeta(): string;
     planJSONExtra(): Record<string, JSONValue | undefined> | undefined;
+    getParentStep(): ExecutableStep;
     [$$deepDepSkip](): ExecutableStep;
     execute(): never;
     unbatchedExecute(): never;

package/dist/steps/__item.js

@@ -30,6 +30,9 @@ class __ItemStep extends step_js_1.UnbatchedExecutableStep {
             transformStepId: this.transformStepId,
         };
     }
+    getParentStep() {
+        return this.getDep(0);
+    }
     [(_a = step_js_1.$$noExec, step_js_1.$$deepDepSkip)]() {
         return this.getDep(0);
     }

package/dist/steps/connection.d.ts

@@ -93,7 +93,7 @@ export declare class ConnectionStep<TItemStep extends ExecutableStep, TCursorSte
      */
     addValidation(callback: () => ExecutableStep): void;
     edges(): ExecutableStep;
-    nodes(): TStep | import("./listTransform.js").__ListTransformStep<any, any, any, any>;
+    nodes(): import("./listTransform.js").__ListTransformStep<any, any, any, any> | TStep;
     wrapEdge($edge: TItemStep): EdgeStep<TItemStep, TCursorStep, TStep, TNodeStep>;
     pageInfo(): PageInfoCapableStep;
     execute(count: number): GrafastResultsList<Record<string, never>>;

package/dist/steps/each.js

@@ -43,7 +43,7 @@ function each(listStep, mapper) {
             const layerPlan = this.subroutineLayer;
             const rootStep = layerPlan.rootStep;
             if (rootStep instanceof __item_js_1.__ItemStep &&
-                rootStep.getDep(0).layerPlan !== layerPlan) {
+                rootStep.getParentStep().layerPlan !== layerPlan) {
                 // We don't do anything; replace ourself with our parent
                 return this.getListStep();
             }

package/dist/steps/load.js

@@ -179,6 +179,7 @@ class LoadStep extends step_js_1.ExecutableStep {
             idByLoad.set(this.load, loadId);
         }
         this.metaKey = `LoadStep|${loadId}|${this.loadOptionsKey}`;
+        super.finalize();
     }
     execute(count, [specs], extra) {
         const meta = extra.meta;

package/dist/steps/object.d.ts

@@ -50,7 +50,7 @@ export declare class ObjectStep<TPlans extends {
     execute(count: number, values: Array<Array<DataFromPlans<TPlans>[keyof TPlans]>>, extra: ExecutionExtra): Array<DataFromPlans<TPlans>>;
     unbatchedExecute(_extra: ExecutionExtra, ..._values: any[]): any;
     deduplicate(peers: ObjectStep<any>[]): ObjectStep<TPlans>[];
-    optimize(opts: StepOptimizeOptions): this | ConstantStep<any>;
+    optimize(opts: StepOptimizeOptions): ConstantStep<any> | this;
     /**
      * Get the original plan with the given key back again.
      */

package/dist/utils.d.ts

@@ -144,5 +144,6 @@ export declare function hasItemPlan(step: ExecutableStep & {
 }): step is ExecutableStep & {
     itemPlan: ($item: ExecutableStep) => ExecutableStep;
 };
+export declare function exportNameHint(obj: any, nameHint: string): void;
 export {};
 //# sourceMappingURL=utils.d.ts.map

package/dist/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasItemPlan = exports.assertNotAsync = exports.canonicalJSONStringify = exports.stepsAreInSamePhase = exports.stepAMayDependOnStepB = exports.stepADependsOnStepB = exports.sudo = exports.isTypePlanned = exports.findVariableNamesUsed = exports.arrayOfLengthCb = exports.arrayOfLength = exports.stack = exports.sharedNull = exports.getEnumValueConfig = exports.inputObjectFieldSpec = exports.newInputObjectTypeBuilder = exports.newGrafastFieldConfigBuilder = exports.objectFieldSpec = exports.newObjectTypeBuilder = exports.objectSpec = exports.arraysMatch = exports.isDeferred = exports.isPromiseLike = exports.isPromise = exports.defaultValueToValueNode = exports.assertNullPrototype = exports.ROOT_VALUE_OBJECT = void 0;
+exports.exportNameHint = exports.hasItemPlan = exports.assertNotAsync = exports.canonicalJSONStringify = exports.stepsAreInSamePhase = exports.stepAMayDependOnStepB = exports.stepADependsOnStepB = exports.sudo = exports.isTypePlanned = exports.findVariableNamesUsed = exports.arrayOfLengthCb = exports.arrayOfLength = exports.stack = exports.sharedNull = exports.getEnumValueConfig = exports.inputObjectFieldSpec = exports.newInputObjectTypeBuilder = exports.newGrafastFieldConfigBuilder = exports.objectFieldSpec = exports.newObjectTypeBuilder = exports.objectSpec = exports.arraysMatch = exports.isDeferred = exports.isPromiseLike = exports.isPromise = exports.defaultValueToValueNode = exports.assertNullPrototype = exports.ROOT_VALUE_OBJECT = void 0;
 const tslib_1 = require("tslib");
 const graphql = tslib_1.__importStar(require("graphql"));
 const assert = tslib_1.__importStar(require("./assert.js"));
@@ -702,4 +702,18 @@ function hasItemPlan(step) {
     return "itemPlan" in step && typeof step.itemPlan === "function";
 }
 exports.hasItemPlan = hasItemPlan;
+function exportNameHint(obj, nameHint) {
+    if ((typeof obj === "object" && obj != null) || typeof obj === "function") {
+        if (!("$exporter$name" in obj)) {
+            Object.defineProperty(obj, "$exporter$name", {
+                writable: true,
+                value: nameHint,
+            });
+        }
+        else if (!obj.$exporter$name) {
+            obj.$exporter$name = nameHint;
+        }
+    }
+}
+exports.exportNameHint = exportNameHint;
 //# sourceMappingURL=utils.js.map

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "0.1.1-beta.5";
+export declare const version = "0.1.1-beta.6";
 //# sourceMappingURL=version.d.ts.map

package/dist/version.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = void 0;
 // This file is autogenerated by /scripts/postversion.mjs
-exports.version = "0.1.1-beta.5";
+exports.version = "0.1.1-beta.6";
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grafast",
-  "version": "0.1.1-beta.5",
+  "version": "0.1.1-beta.6",
   "description": "Cutting edge GraphQL planning and execution engine",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -61,14 +61,14 @@
     "eventemitter3": "^5.0.1",
     "graphql": "^16.1.0-experimental-stream-defer.6",
     "iterall": "^1.3.0",
-    "tamedevil": "^0.0.0-beta.5",
+    "tamedevil": "^0.0.0-beta.6",
     "tslib": "^2.6.2"
   },
   "peerDependencies": {
     "@envelop/core": "^3.0.4",
     "graphile-config": "^0.0.1-beta.7",
     "graphql": "^16.1.0-experimental-stream-defer.6",
-    "tamedevil": "^0.0.0-beta.5"
+    "tamedevil": "^0.0.0-beta.6"
   },
   "peerDependenciesMeta": {
     "@envelop/core": {