grafast 0.1.1-beta.16 → 0.1.1-beta.18

package/dist/engine/OperationPlan.d.ts

@@ -190,5 +190,19 @@ export declare class OperationPlan {
     getStepsByStepClass<TClass extends ExecutableStep>(klass: {
         new (...args: any[]): TClass;
     }): TClass[];
+    private _cacheStepStoreByLayerPlanAndActionKey;
+    /**
+     * Cache a generated step by a given identifier (cacheKey) such that we don't
+     * need to regenerate it on future calls, significantly reducing the load on
+     * deduplication later.
+     *
+     * @experimental
+     */
+    cacheStep<T extends ExecutableStep>(ownerStep: ExecutableStep, actionKey: string, cacheKey: symbol | string | number, cb: () => T): T;
+    /**
+     * Clears the cache, typically due to side effects having taken place. Called
+     * from setting hasSideEffects on an ExecutableStep, among other places.
+     */
+    resetCache(): void;
 }
 //# sourceMappingURL=OperationPlan.d.ts.map

package/dist/engine/OperationPlan.js

@@ -137,6 +137,7 @@ class OperationPlan {
                 return step[interfaces_js_1.$$proxy] ?? step;
             };
         this.polymorphicLayerPlanByPathByLayerPlan = new Map();
+        this._cacheStepStoreByLayerPlanAndActionKey = Object.create(null);
         this.scalarPlanInfo = { schema: this.schema };
         const queryType = schema.getQueryType();
         assert.ok(queryType, "Schema must have a query type");
@@ -187,11 +188,13 @@ class OperationPlan {
         this.lap("hoistSteps", "planOperation");
         if (index_js_1.isDev) {
             this.phase = "validate";
+            this.resetCache();
             // Helpfully check steps don't do forbidden things.
             this.validateSteps();
             this.lap("validateSteps");
         }
         this.phase = "optimize";
+        this.resetCache();
         // Get rid of temporary steps before `optimize` triggers side-effects.
         // (Critical due to steps that may have been discarded due to field errors
         // or similar.)
@@ -208,6 +211,7 @@ class OperationPlan {
         this.checkTimeout();
         this.lap("inlineSteps");
         this.phase = "finalize";
+        this.resetCache();
         this.stepTracker.finalizeSteps();
         // Get rid of steps that are no longer needed after optimising outputPlans
         // (we shouldn't see any new steps or dependencies after here)
@@ -244,6 +248,7 @@ class OperationPlan {
         });
         this.lap("finalizeOutputPlans");
         this.phase = "ready";
+        this.resetCache();
         // this.walkFinalizedPlans();
         // this.preparePrefetches();
         const allMetaKeys = new Set();
@@ -1409,15 +1414,16 @@ class OperationPlan {
         if (step.hasSideEffects) {
             return EMPTY_ARRAY;
         }
-        const { dependencies: deps, dependencyForbiddenFlags: flags, dependencyOnReject: onReject, layerPlan: layerPlan, constructor: stepConstructor, } = (0, utils_js_1.sudo)(step);
+        const { dependencies: deps, dependencyForbiddenFlags: flags, dependencyOnReject: onReject, layerPlan: layerPlan, constructor: stepConstructor, peerKey, } = (0, utils_js_1.sudo)(step);
         const dependencyCount = deps.length;
         if (dependencyCount === 0) {
             let allPeers = null;
-            for (const possiblyPeer of this.stepTracker.stepsWithNoDependencies) {
+            const stepsWithNoDependencies = this.stepTracker.stepsWithNoDependenciesByConstructor.get(step.constructor) ?? new Set();
+            for (const possiblyPeer of stepsWithNoDependencies) {
                 if (possiblyPeer !== step &&
                     !possiblyPeer.hasSideEffects &&
                     possiblyPeer.layerPlan === layerPlan &&
-                    possiblyPeer.constructor === stepConstructor) {
+                    possiblyPeer.peerKey === peerKey) {
                     if (allPeers === null) {
                         allPeers = [possiblyPeer];
                     }
@@ -1441,14 +1447,17 @@ class OperationPlan {
             const minDepth = Math.max(deferBoundaryDepth, dep.layerPlan.depth);
             let allPeers = null;
             for (const { dependencyIndex: peerDependencyIndex, step: rawPossiblyPeer, } of dep.dependents) {
+                if (peerDependencyIndex !== 0 ||
+                    rawPossiblyPeer === step ||
+                    rawPossiblyPeer.hasSideEffects ||
+                    rawPossiblyPeer.constructor !== stepConstructor ||
+                    rawPossiblyPeer.peerKey !== peerKey) {
+                    continue;
+                }
                 const possiblyPeer = (0, utils_js_1.sudo)(rawPossiblyPeer);
                 const { layerPlan: peerLayerPlan, dependencyForbiddenFlags: peerFlags, dependencyOnReject: peerOnReject, } = possiblyPeer;
-                if (possiblyPeer !== step &&
-                    peerDependencyIndex === 0 &&
-                    !possiblyPeer.hasSideEffects &&
-                    possiblyPeer.constructor === stepConstructor &&
-                    peerLayerPlan.depth >= minDepth &&
-                    (0, utils_js_1.sudo)(possiblyPeer).dependencies.length === dependencyCount &&
+                if (peerLayerPlan.depth >= minDepth &&
+                    possiblyPeer.dependencies.length === dependencyCount &&
                     peerLayerPlan === ancestry[peerLayerPlan.depth] &&
                     peerFlags[0] === flags[0] &&
                     peerOnReject[0] === onReject[0]) {
@@ -1475,7 +1484,8 @@ class OperationPlan {
              */
             let minDepth = deferBoundaryDepth;
             const possiblePeers = [];
-            for (let dependencyIndex = 0; dependencyIndex < dependencyCount; dependencyIndex++) {
+            // Loop backwards since last dependency is most likely to be most unique
+            for (let dependencyIndex = dependencyCount - 1; dependencyIndex >= 0; dependencyIndex--) {
                 const dep = deps[dependencyIndex];
                 const dl = dep.dependents.length;
                 if (dl === 1) {
@@ -1488,13 +1498,16 @@ class OperationPlan {
                     // dependents (since it was added last it's more likely to be
                     // unique).
                     for (const { dependencyIndex: peerDependencyIndex, step: rawPossiblyPeer, } of dep.dependents) {
+                        if (peerDependencyIndex !== dependencyIndex ||
+                            rawPossiblyPeer === step ||
+                            rawPossiblyPeer.hasSideEffects ||
+                            rawPossiblyPeer.constructor !== stepConstructor ||
+                            rawPossiblyPeer.peerKey !== peerKey) {
+                            continue;
+                        }
                         const possiblyPeer = (0, utils_js_1.sudo)(rawPossiblyPeer);
                         const { layerPlan: peerLayerPlan, dependencyForbiddenFlags: peerFlags, dependencyOnReject: peerOnReject, dependencies: peerDependencies, } = possiblyPeer;
-                        if (possiblyPeer !== step &&
-                            peerDependencyIndex === dependencyIndex &&
-                            !possiblyPeer.hasSideEffects &&
-                            possiblyPeer.constructor === stepConstructor &&
-                            peerDependencies.length === dependencyCount &&
+                        if (peerDependencies.length === dependencyCount &&
                             peerLayerPlan === ancestry[peerLayerPlan.depth] &&
                             peerFlags[0] === flags[0] &&
                             peerOnReject[0] === onReject[0]) {
@@ -2611,6 +2624,38 @@ class OperationPlan {
         }
         return matches;
     }
+    /**
+     * Cache a generated step by a given identifier (cacheKey) such that we don't
+     * need to regenerate it on future calls, significantly reducing the load on
+     * deduplication later.
+     *
+     * @experimental
+     */
+    cacheStep(ownerStep, actionKey, cacheKey, cb) {
+        const layerPlan = (0, withGlobalLayerPlan_js_1.currentLayerPlan)();
+        const cache = (this._cacheStepStoreByLayerPlanAndActionKey[`${actionKey}|${layerPlan.id}|${ownerStep.id}`] ??= Object.create(null));
+        const cacheIt = () => {
+            const stepToCache = cb();
+            if (!(stepToCache instanceof index_js_1.ExecutableStep)) {
+                throw new Error(`The callback passed to cacheStep must always return an ExecutableStep; but this call from ${ownerStep} returned instead ${(0, inspect_js_1.inspect)(stepToCache)}`);
+            }
+            cache[cacheKey] = stepToCache.id;
+            return stepToCache;
+        };
+        if (!(cacheKey in cache)) {
+            return cacheIt();
+        }
+        const cachedStepId = cache[cacheKey];
+        const cachedStep = this.stepTracker.stepById[cachedStepId];
+        return cachedStep ?? cacheIt();
+    }
+    /**
+     * Clears the cache, typically due to side effects having taken place. Called
+     * from setting hasSideEffects on an ExecutableStep, among other places.
+     */
+    resetCache() {
+        this._cacheStepStoreByLayerPlanAndActionKey = Object.create(null);
+    }
 }
 exports.OperationPlan = OperationPlan;
 function makeDefaultPlan(fieldName) {

package/dist/engine/StepTracker.js

@@ -30,7 +30,7 @@ class StepTracker {
         /** @internal */
         this.aliasesById = [];
         /** @internal */
-        this.stepsWithNoDependencies = new Set();
+        this.stepsWithNoDependenciesByConstructor = new Map();
         /** @internal */
         this.outputPlansByRootStep = new Map();
         /** @internal */
@@ -73,7 +73,13 @@ class StepTracker {
     addStep($step) {
         const stepId = this.stepCount++;
         this.activeSteps.add($step);
-        this.stepsWithNoDependencies.add($step);
+        const ctor = $step.constructor;
+        let stepsWithNoDependencies = this.stepsWithNoDependenciesByConstructor.get(ctor);
+        if (!stepsWithNoDependencies) {
+            stepsWithNoDependencies ??= new Set();
+            this.stepsWithNoDependenciesByConstructor.set(ctor, stepsWithNoDependencies);
+        }
+        stepsWithNoDependencies.add($step);
         this.stepById[stepId] = $step;
         this.aliasesById[stepId] = undefined;
         this.addStepToItsLayerPlan($step);
@@ -253,7 +259,9 @@ class StepTracker {
             $dependent._isUnary = false;
         }
         const forbiddenFlags = interfaces_js_1.ALL_FLAGS & ~(acceptFlags & interfaces_js_1.TRAPPABLE_FLAGS);
-        this.stepsWithNoDependencies.delete($dependent);
+        this.stepsWithNoDependenciesByConstructor
+            .get($dependent.constructor)
+            ?.delete($dependent);
         const dependencyIndex = dependentDependencies.push($dependency) - 1;
         dependentDependencyForbiddenFlags[dependencyIndex] = forbiddenFlags;
         dependentDependencyOnReject[dependencyIndex] = onReject;
@@ -538,7 +546,9 @@ class StepTracker {
                 ]}`);
             }
         }
-        this.stepsWithNoDependencies.delete($original);
+        this.stepsWithNoDependenciesByConstructor
+            .get($original.constructor)
+            ?.delete($original);
         this.outputPlansByRootStep.delete($original);
         this.layerPlansByRootStep.delete($original);
         this.layerPlansByParentStep.delete($original);

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/index.d.ts

@@ -1,6 +1,6 @@
 import "./thereCanBeOnlyOne.js";
 import type LRU from "@graphile/lru";
-import type { CallbackOrDescriptor, MiddlewareNext } from "graphile-config";
+import type { MiddlewareHandlers } from "graphile-config";
 import type { DocumentNode, GraphQLError, OperationDefinitionNode } from "graphql";
 import type { DataFromObjectSteps } from "./steps/object.js";
 type PromiseOrValue<T> = T | Promise<T>;
@@ -160,9 +160,7 @@ declare global {
         }
         interface Plugin {
             grafast?: {
-                middleware?: {
-                    [key in keyof GrafastMiddleware]?: CallbackOrDescriptor<GrafastMiddleware[key] extends (...args: infer UArgs) => infer UResult ? (next: MiddlewareNext<UResult>, ...args: UArgs) => UResult : never>;
-                };
+                middleware?: MiddlewareHandlers<GrafastMiddleware>;
             };
         }
     }

package/dist/step.d.ts

@@ -108,6 +108,18 @@ export declare class ExecutableStep<TData = any> extends BaseStep {
      * Like `metaKey` but for the optimize phase
      */
     optimizeMetaKey: number | string | symbol | undefined;
+    /**
+     * If the peerKey of two steps do not match, then they are definitely not
+     * peers. Use this to reduce the load on deduplicate by more quickly
+     * eradicating definitely-not-peers.
+     *
+     * Note: we may well change this to be a function in future, so it's advised
+     * that you don't use this unless you're working inside the graphile/crystal
+     * core codebase.
+     *
+     * @experimental
+     */
+    peerKey: string | null;
     /**
      * Set this true for plans that implement mutations; this will prevent them
      * from being tree-shaken.
@@ -125,6 +137,14 @@ export declare class ExecutableStep<TData = any> extends BaseStep {
      * @experimental
      */
     protected getDepDeep(depId: number): ExecutableStep;
+    /**
+     * Cache a generated step by a given identifier (cacheKey) such that we don't
+     * need to regenerate it on future calls, significantly reducing the load on
+     * deduplication later.
+     *
+     * @experimental
+     */
+    protected cacheStep<T extends ExecutableStep>(actionKey: string, cacheKey: symbol | string | number, cb: () => T): T;
     toString(): string;
     protected canAddDependency(step: ExecutableStep): boolean;
     protected addDependency(stepOrOptions: ExecutableStep | AddDependencyOptions): number;

package/dist/step.js

@@ -107,6 +107,18 @@ class ExecutableStep extends BaseStep {
          * (default = ALL_FLAGS & ~FLAG_NULL)
          */
         this.defaultForbiddenFlags = interfaces_js_1.DEFAULT_FORBIDDEN_FLAGS;
+        /**
+         * If the peerKey of two steps do not match, then they are definitely not
+         * peers. Use this to reduce the load on deduplicate by more quickly
+         * eradicating definitely-not-peers.
+         *
+         * Note: we may well change this to be a function in future, so it's advised
+         * that you don't use this unless you're working inside the graphile/crystal
+         * core codebase.
+         *
+         * @experimental
+         */
+        this.peerKey = null;
         this.implicitSideEffectStep = null;
         this.hasSideEffects ??= false;
         let hasSideEffects = false;
@@ -144,6 +156,7 @@ class ExecutableStep extends BaseStep {
                     hasSideEffects = value;
                     if (value === true) {
                         this.layerPlan.latestSideEffectStep = this;
+                        this.operationPlan.resetCache();
                     }
                     else if (value !== true && hasSideEffects === true) {
                         throw new Error(`Cannot mark ${this} as having no side effects after having set it to have side effects.`);
@@ -205,6 +218,16 @@ class ExecutableStep extends BaseStep {
         }
         return $dep;
     }
+    /**
+     * Cache a generated step by a given identifier (cacheKey) such that we don't
+     * need to regenerate it on future calls, significantly reducing the load on
+     * deduplication later.
+     *
+     * @experimental
+     */
+    cacheStep(actionKey, cacheKey, cb) {
+        return this.operationPlan.cacheStep(this, actionKey, cacheKey, cb);
+    }
     toString() {
         let meta;
         try {

package/dist/steps/__value.js

@@ -37,10 +37,10 @@ class __ValueStep extends step_js_1.ExecutableStep {
         throw new Error(`GrafastInternalError<7696a514-f452-4d47-92d3-85aeb5b23f48>: ${this} is a __ValueStep and thus must never execute`);
     }
     get(attrName) {
-        return (0, access_js_1.access)(this, [attrName]);
+        return this.cacheStep("get", attrName, () => (0, access_js_1.access)(this, [attrName]));
     }
     at(index) {
-        return (0, access_js_1.access)(this, [index]);
+        return this.cacheStep("at", index, () => (0, access_js_1.access)(this, [index]));
     }
 }
 exports.__ValueStep = __ValueStep;

package/dist/steps/access.d.ts

@@ -18,6 +18,7 @@ export declare class AccessStep<TData> extends UnbatchedExecutableStep<TData> {
     isSyncAndSafe: boolean;
     allowMultipleOptimizations: boolean;
     readonly path: (string | number | symbol)[];
+    private readonly hasSymbols;
     constructor(parentPlan: ExecutableStep<unknown>, path: (string | number | symbol)[], fallback?: any);
     toStringMeta(): string;
     /**
@@ -37,5 +38,5 @@ export declare class AccessStep<TData> extends UnbatchedExecutableStep<TData> {
  * Access the property at path `path` in the value returned from `parentPlan`,
  * falling back to `fallback` if it were null-ish.
  */
-export declare function access<TData>(parentPlan: ExecutableStep<unknown>, path?: (string | number | symbol)[] | string | number | symbol, fallback?: any): AccessStep<TData>;
+export declare function access<TData>(parentPlan: ExecutableStep<unknown>, rawPath?: (string | number | symbol)[] | string | number | symbol, fallback?: any): AccessStep<TData>;
 //# sourceMappingURL=access.d.ts.map

package/dist/steps/access.js

@@ -3,10 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.access = exports.AccessStep = exports.expressionSymbol = void 0;
 const tslib_1 = require("tslib");
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
-const debug_1 = tslib_1.__importDefault(require("debug"));
 const tamedevil_1 = tslib_1.__importDefault(require("tamedevil"));
 const inspect_js_1 = require("../inspect.js");
 const step_js_1 = require("../step.js");
+const utils_js_1 = require("../utils.js");
 /** @internal */
 exports.expressionSymbol = Symbol("expression");
 const makeDestructureCache = Object.create(null);
@@ -100,8 +100,6 @@ return (_meta, value) => value?.${tamedevil_1.default.join(access, "?.")}${fallb
         });
     }
 }
-const debugAccessPlan = (0, debug_1.default)("grafast:AccessStep");
-const debugAccessPlanVerbose = debugAccessPlan.extend("verbose");
 /**
  * Accesses a (potentially nested) property from the result of a plan.
  *
@@ -121,6 +119,11 @@ class AccessStep extends step_js_1.UnbatchedExecutableStep {
         this.isSyncAndSafe = true;
         this.allowMultipleOptimizations = true;
         this.path = path;
+        this.hasSymbols = this.path.some((k) => typeof k === "symbol");
+        this.peerKey =
+            (this.fallback === "undefined" ? "U" : "D") +
+                (this.hasSymbols ? "§" : ".") +
+                (0, utils_js_1.digestKeys)(this.path);
         this.addDependency(parentPlan);
     }
     toStringMeta() {
@@ -135,7 +138,7 @@ class AccessStep extends step_js_1.UnbatchedExecutableStep {
         if (typeof attrName !== "string") {
             throw new Error(`AccessStep::get can only be called with string values`);
         }
-        return new AccessStep(this.getDep(0), [...this.path, attrName]);
+        return access(this.getDep(0), [...this.path, attrName]);
     }
     /**
      * Get the entry at the given index in an array.
@@ -144,7 +147,7 @@ class AccessStep extends step_js_1.UnbatchedExecutableStep {
         if (typeof index !== "number") {
             throw new Error(`AccessStep::get can only be called with string values`);
         }
-        return new AccessStep(this.getDep(0), [...this.path, index]);
+        return access(this.getDep(0), [...this.path, index]);
     }
     // An access of an access can become a single access
     optimize() {
@@ -165,10 +168,23 @@ class AccessStep extends step_js_1.UnbatchedExecutableStep {
         throw new Error(`${this}: should have had unbatchedExecute method replaced`);
     }
     deduplicate(peers) {
-        const myPath = JSON.stringify(this.path);
-        const peersWithSamePath = peers.filter((p) => p.fallback === this.fallback && JSON.stringify(p.path) === myPath);
-        debugAccessPlanVerbose("%c deduplicate: peers with same path %o = %c", this, this.path, peersWithSamePath);
-        return peersWithSamePath;
+        if (peers.length === 0) {
+            return peers;
+        }
+        else if (!this.hasSymbols && this.fallback === undefined) {
+            // Rely entirely on peerKey
+            return peers;
+        }
+        else if (!this.hasSymbols) {
+            // Rely on peerKey for path, but check fallback
+            const { fallback } = this;
+            return peers.filter((p) => p.fallback === fallback);
+        }
+        else {
+            // Check both fallback and path
+            const { fallback, path } = this;
+            return peers.filter((p) => p.fallback === fallback && (0, utils_js_1.arraysMatch)(p.path, path));
+        }
     }
 }
 exports.AccessStep = AccessStep;
@@ -176,8 +192,18 @@ exports.AccessStep = AccessStep;
  * Access the property at path `path` in the value returned from `parentPlan`,
  * falling back to `fallback` if it were null-ish.
  */
-function access(parentPlan, path, fallback) {
-    return new AccessStep(parentPlan, Array.isArray(path) ? path : path != null ? [path] : [], fallback);
+function access(parentPlan, rawPath, fallback) {
+    const path = Array.isArray(rawPath)
+        ? rawPath
+        : rawPath != null
+            ? [rawPath]
+            : [];
+    if (typeof fallback === "undefined" &&
+        !path.some((k) => typeof k === "symbol")) {
+        const pathKey = (0, utils_js_1.digestKeys)(path);
+        return parentPlan.operationPlan.cacheStep(parentPlan, "GrafastInternal:access()", pathKey, () => new AccessStep(parentPlan, path));
+    }
+    return new AccessStep(parentPlan, path, fallback);
 }
 exports.access = access;
 //# sourceMappingURL=access.js.map

package/dist/steps/applyTransforms.js

@@ -160,7 +160,7 @@ exports.ApplyTransformsStep = ApplyTransformsStep;
  */
 function applyTransforms($step) {
     if ((0, step_js_1.isListCapableStep)($step)) {
-        return new ApplyTransformsStep($step);
+        return $step.operationPlan.cacheStep($step, "GrafastInternal:applyTransforms()", "", () => new ApplyTransformsStep($step));
     }
     else {
         // No eval necessary

package/dist/steps/constant.js

@@ -17,6 +17,13 @@ class ConstantStep extends step_js_1.UnbatchedExecutableStep {
         this.data = data;
         this.isSensitive = isSensitive;
         this.isSyncAndSafe = true;
+        const t = typeof data;
+        if (data == null ||
+            t === "boolean" ||
+            t === "number" ||
+            (t === "string" && t.length < 200)) {
+            this.peerKey = t + "|" + String(data);
+        }
     }
     toStringMeta() {
         // ENHANCE: use nicer simplification

package/dist/steps/first.js

@@ -38,7 +38,7 @@ exports.FirstStep = FirstStep;
  * plan.
  */
 function first(plan) {
-    return new FirstStep(plan);
+    return plan.operationPlan.cacheStep(plan, "GrafastInternal:first()", "", () => new FirstStep(plan));
 }
 exports.first = first;
 //# sourceMappingURL=first.js.map

package/dist/steps/last.js

@@ -35,7 +35,7 @@ exports.LastStep = LastStep;
  * plan.
  */
 function last(plan) {
-    return new LastStep(plan);
+    return plan.operationPlan.cacheStep(plan, "GrafastInternal:last()", "", () => new LastStep(plan));
 }
 exports.last = last;
 //# sourceMappingURL=last.js.map

package/dist/steps/load.d.ts

@@ -40,6 +40,7 @@ export declare class LoadedRecordStep<TItem, TParams extends Record<string, any>
     constructor($data: ExecutableStep<TItem>, isSingle: boolean, sourceDescription: string, ioEquivalence: Record<string, ExecutableStep>);
     toStringMeta(): string;
     get(attr: keyof TItem & (string | number)): ExecutableStep<any>;
+    private _getInner;
     setParam<TParamKey extends keyof TParams>(paramKey: TParamKey, value: TParams[TParamKey]): void;
     optimize(): ExecutableStep<any>;
     execute({ count, values: [values0], }: ExecutionDetails<[TItem]>): GrafastResultsList<TItem>;

package/dist/steps/load.js

@@ -48,6 +48,9 @@ class LoadedRecordStep extends step_js_1.ExecutableStep {
         return this.sourceDescription ?? null;
     }
     get(attr) {
+        return this.cacheStep("get", attr, () => this._getInner(attr));
+    }
+    _getInner(attr) {
         // Allow auto-collapsing of the waterfall by knowing keys are equivalent
         if (this.operationPlan.phase === "plan" &&
             this.ioEquivalence[attr]) {

package/dist/steps/object.d.ts

@@ -32,16 +32,18 @@ export declare class ObjectStep<TPlans extends {
 } = {
     [key: string]: ExecutableStep;
 }> extends UnbatchedExecutableStep<DataFromObjectSteps<TPlans>> implements SetterCapableStep<TPlans> {
+    private cacheConfig?;
     static $$export: {
         moduleName: string;
         exportName: string;
     };
     isSyncAndSafe: boolean;
     allowMultipleOptimizations: boolean;
-    private keys;
+    private readonly keys;
     optimizeMetaKey: string;
     private cacheSize;
-    constructor(obj: TPlans, cacheConfig?: ObjectStepCacheConfig);
+    constructor(obj: TPlans, cacheConfig?: ObjectStepCacheConfig | undefined);
+    private _setKeys;
     /**
      * This key doesn't get typed, but it can be added later which can be quite
      * handy.

package/dist/steps/object.js

@@ -5,6 +5,7 @@ exports.object = exports.ObjectStep = void 0;
 const tslib_1 = require("tslib");
 const tamedevil_1 = tslib_1.__importStar(require("tamedevil"));
 const step_js_1 = require("../step.js");
+const utils_js_1 = require("../utils.js");
 const constant_js_1 = require("./constant.js");
 const DEFAULT_CACHE_SIZE = 100;
 const EMPTY_OBJECT = Object.freeze(Object.create(null));
@@ -19,30 +20,37 @@ class ObjectStep extends step_js_1.UnbatchedExecutableStep {
     }; }
     constructor(obj, cacheConfig) {
         super();
+        this.cacheConfig = cacheConfig;
         this.isSyncAndSafe = true;
         this.allowMultipleOptimizations = true;
+        this.keys = [];
         // Optimize needs the same 'meta' for all ObjectSteps
         this.optimizeMetaKey = "ObjectStep";
         this.cacheSize =
             cacheConfig?.cacheSize ??
                 (cacheConfig?.identifier ? DEFAULT_CACHE_SIZE : 0);
+        const keys = Object.keys(obj);
+        this._setKeys(keys);
+        for (let i = 0, l = this.keys.length; i < l; i++) {
+            this.addDependency({ step: obj[keys[i]], skipDeduplication: true });
+        }
+    }
+    _setKeys(keys) {
+        this.keys = keys;
+        this.peerKey = (0, utils_js_1.digestKeys)(keys);
         this.metaKey =
             this.cacheSize <= 0
                 ? undefined
-                : cacheConfig?.identifier
-                    ? `object|${JSON.stringify(Object.keys(obj))}|${cacheConfig.identifier}`
+                : this.cacheConfig?.identifier
+                    ? `object|${this.peerKey}|${this.cacheConfig.identifier}`
                     : this.id;
-        this.keys = Object.keys(obj);
-        for (let i = 0, l = this.keys.length; i < l; i++) {
-            this.addDependency({ step: obj[this.keys[i]], skipDeduplication: true });
-        }
     }
     /**
      * This key doesn't get typed, but it can be added later which can be quite
      * handy.
      */
     set(key, plan) {
-        this.keys.push(key);
+        this._setKeys([...this.keys, key]);
         this.addDependency({ step: plan, skipDeduplication: true });
     }
     getStepForKey(key, allowMissing = false) {
@@ -154,8 +162,8 @@ ${inner}
         throw new Error(`${this} didn't finalize? No unbatchedExecute method.`);
     }
     deduplicate(peers) {
-        const myKeys = JSON.stringify(this.keys);
-        return peers.filter((p) => JSON.stringify(p.keys) === myKeys);
+        // Managed through peerKey
+        return peers;
     }
     optimize(opts) {
         if (this.dependencies.every((dep) => dep instanceof constant_js_1.ConstantStep)) {

package/dist/steps/remapKeys.d.ts

@@ -9,7 +9,7 @@ export type ActualKeyByDesiredKey = {
  * `actualKey` from the input and storing it as the `desiredKey` in the output.
  */
 export declare class RemapKeysStep extends UnbatchedExecutableStep {
-    private actualKeyByDesiredKey;
+    private readonly actualKeyByDesiredKey;
     static $$export: {
         moduleName: string;
         exportName: string;

package/dist/steps/remapKeys.js

@@ -6,6 +6,7 @@ const tslib_1 = require("tslib");
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const tamedevil_1 = tslib_1.__importStar(require("tamedevil"));
 const step_js_1 = require("../step.js");
+const utils_js_1 = require("../utils.js");
 function makeMapper(actualKeyByDesiredKey, callback) {
     const entries = Object.entries(actualKeyByDesiredKey);
     if (entries.every(([key, val]) => (0, tamedevil_1.isSafeObjectPropertyName)(key) && (0, tamedevil_1.isSafeObjectPropertyName)(val))) {
@@ -40,6 +41,10 @@ class RemapKeysStep extends step_js_1.UnbatchedExecutableStep {
         this.isSyncAndSafe = true;
         this.allowMultipleOptimizations = true;
         this.addDependency($plan);
+        this.peerKey = (0, utils_js_1.digestKeys)([
+            ...Object.keys(this.actualKeyByDesiredKey),
+            ...Object.values(this.actualKeyByDesiredKey),
+        ]);
     }
     toStringMeta() {
         return (chalk_1.default.bold.yellow(String(this.dependencies[0].id)) +
@@ -70,8 +75,8 @@ class RemapKeysStep extends step_js_1.UnbatchedExecutableStep {
         return this.mapper(value);
     }
     deduplicate(peers) {
-        const myMap = JSON.stringify(this.actualKeyByDesiredKey);
-        return peers.filter((p) => JSON.stringify(p.actualKeyByDesiredKey) === myMap);
+        // Handled by peerKey
+        return peers;
     }
 }
 exports.RemapKeysStep = RemapKeysStep;

package/dist/steps/reverse.js

@@ -49,7 +49,7 @@ exports.ReverseStep = ReverseStep;
  * Reverses a list.
  */
 function reverse(plan) {
-    return new ReverseStep(plan);
+    return plan.operationPlan.cacheStep(plan, "GrafastInternal:reverse()", "", () => new ReverseStep(plan));
 }
 exports.reverse = reverse;
 //# sourceMappingURL=reverse.js.map

package/dist/utils.d.ts

@@ -151,5 +151,11 @@ export declare function hasItemPlan(step: ExecutableStep & {
 };
 export declare function exportNameHint(obj: any, nameHint: string): void;
 export declare function isTuple<T extends readonly [...(readonly any[])]>(t: any | T): t is T;
+/**
+ * Turns an array of keys into a digest, avoiding conflicts.
+ * Symbols are treated as equivalent. (Theoretically faster
+ * than JSON.stringify().)
+ */
+export declare function digestKeys(keys: ReadonlyArray<string | number | symbol>): string;
 export {};
 //# sourceMappingURL=utils.d.ts.map

package/dist/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isTuple = exports.exportNameHint = exports.hasItemPlan = exports.assertNotPromise = exports.assertNotAsync = exports.canonicalJSONStringify = exports.stepsAreInSamePhase = exports.stepAMayDependOnStepB = exports.stepADependsOnStepB = exports.writeableArray = 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.digestKeys = exports.isTuple = exports.exportNameHint = exports.hasItemPlan = exports.assertNotPromise = exports.assertNotAsync = exports.canonicalJSONStringify = exports.stepsAreInSamePhase = exports.stepAMayDependOnStepB = exports.stepADependsOnStepB = exports.writeableArray = 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"));
@@ -756,4 +756,27 @@ function isTuple(t) {
     return Array.isArray(t);
 }
 exports.isTuple = isTuple;
+/**
+ * Turns an array of keys into a digest, avoiding conflicts.
+ * Symbols are treated as equivalent. (Theoretically faster
+ * than JSON.stringify().)
+ */
+function digestKeys(keys) {
+    let str = "";
+    for (let i = 0, l = keys.length; i < l; i++) {
+        const item = keys[i];
+        if (typeof item === "string") {
+            // str += `|§${item.replace(/§/g, "§§")}§`;
+            str += `§${item.length}:${item}`;
+        }
+        else if (typeof item === "number") {
+            str += `N${item}`;
+        }
+        else {
+            str += "!";
+        }
+    }
+    return str;
+}
+exports.digestKeys = digestKeys;
 //# sourceMappingURL=utils.js.map

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "0.1.1-beta.16";
+export declare const version = "0.1.1-beta.18";
 //# 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.16";
+exports.version = "0.1.1-beta.18";
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grafast",
-  "version": "0.1.1-beta.16",
+  "version": "0.1.1-beta.18",
   "description": "Cutting edge GraphQL planning and execution engine",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -59,7 +59,7 @@
     "chalk": "^4.1.2",
     "debug": "^4.3.4",
     "eventemitter3": "^5.0.1",
-    "graphile-config": "^0.0.1-beta.11",
+    "graphile-config": "^0.0.1-beta.13",
     "graphql": "^16.1.0-experimental-stream-defer.6",
     "iterall": "^1.3.0",
     "tamedevil": "^0.0.0-beta.7",