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

package/dist/engine/LayerPlan.js

@@ -0,0 +1,536 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LayerPlan = exports.isPolymorphicLayerPlan = exports.isDeferredLayerPlan = exports.isBranchingLayerPlan = void 0;
+const tslib_1 = require("tslib");
+const lru_1 = tslib_1.__importDefault(require("@graphile/lru"));
+const tamedevil_1 = tslib_1.__importDefault(require("tamedevil"));
+const assert = tslib_1.__importStar(require("../assert.js"));
+const error_js_1 = require("../error.js");
+const inspect_js_1 = require("../inspect.js");
+const polymorphic_js_1 = require("../polymorphic.js");
+const executeBucket_js_1 = require("./executeBucket.js");
+function isBranchingLayerPlan(layerPlan) {
+    return layerPlan.reason.type === "polymorphic";
+}
+exports.isBranchingLayerPlan = isBranchingLayerPlan;
+function isDeferredLayerPlan(layerPlan) {
+    const t = layerPlan.reason.type;
+    return (t === "stream" ||
+        t === "subscription" ||
+        t === "mutationField" ||
+        t === "defer");
+}
+exports.isDeferredLayerPlan = isDeferredLayerPlan;
+function isPolymorphicLayerPlan(layerPlan) {
+    const t = layerPlan.reason.type;
+    return t === "polymorphic";
+}
+exports.isPolymorphicLayerPlan = isPolymorphicLayerPlan;
+/**
+ * A LayerPlan represents (via "reason") either the root (root), when something
+ * happens at a later time (mutationField, defer), when plurality changes
+ * (list, stream, subscription, polymorphic), or when a subprocess needs to be
+ * computed (subroutine).
+ *
+ * Layer plans belong to an operation plan.
+ *
+ * Every layer plan (except for the root layer plan) has exactly one parent
+ * layer plan.
+ *
+ * Every layer plan is caused by a parent step.
+ *
+ * The LayerPlan of a step influences:
+ *
+ * 1. how steps are deduplicated
+ * 2. the order in which the steps are executed
+ * 3. where the result of executing the step is stored
+ * 4. when the step execution cache is allowed to be GC'd
+ *
+ * NOTE: `__ListTransformStep`'s effectively have a temporary bucket inside
+ * them (built on the `__Item`) that's thrown away once the transform is
+ * complete.
+ *
+ */
+class LayerPlan {
+    constructor(operationPlan, parentLayerPlan, reason) {
+        this.operationPlan = operationPlan;
+        this.parentLayerPlan = parentLayerPlan;
+        this.reason = reason;
+        /**
+         * Every layer plan has a "root step" that shapes the value the layer
+         * returns. Note that this step may be dependent on other steps included in
+         * the LayerPlan, or could be provided externally.
+         *
+         * The root step is different for different layer step reasons:
+         *
+         * - root: the `operationPlan.rootValue`
+         * - listItem: the `__ItemStep`
+         * - stream: also the `__ItemStep`
+         * - subscription: also the `__ItemStep`
+         * - mutationField: the result plan of the mutation field
+         * - defer: the parent layer's rootStep (defer always results in an object, unless an error occurs)
+         * - polymorphic: the plan for the particular type
+         * - subroutine: the result (returned) plan of the subroutine
+         *
+         * @internal
+         */
+        this.rootStep = null;
+        /**
+         * Which plans the results for which are available in a parent bucket need to
+         * be "copied across" to this bucket because plans in this bucket still
+         * reference them?
+         *
+         * @internal
+         */
+        this.copyStepIds = [];
+        /** @internal */
+        this.children = [];
+        /** @internal */
+        this.steps = [];
+        /** @internal */
+        this.pendingSteps = [];
+        /**
+         * Describes the order in which the steps within this LayerPlan are executed.
+         *
+         * Special attention must be paid to steps that have side effects.
+         *
+         * @internal
+         */
+        this.phases = [];
+        this.stepsByConstructor = new Map();
+        if (parentLayerPlan !== null) {
+            this.depth = parentLayerPlan.depth + 1;
+            this.ancestry = [...parentLayerPlan.ancestry, this];
+            if (isDeferredLayerPlan(this)) {
+                this.deferBoundaryDepth = this.depth;
+            }
+            else {
+                this.deferBoundaryDepth = parentLayerPlan.deferBoundaryDepth;
+            }
+        }
+        else {
+            this.depth = 0;
+            this.ancestry = [this];
+            this.deferBoundaryDepth = 0;
+        }
+        this.id = operationPlan.addLayerPlan(this);
+        if (!parentLayerPlan) {
+            assert.strictEqual(this.id, 0, "All but the first LayerPlan must have a parent");
+        }
+        else {
+            assert.ok(reason.type != "root", "Non-root LayerPlan must have a parentStep");
+            parentLayerPlan.children.push(this);
+        }
+    }
+    toString() {
+        let chain = "";
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        let current = this;
+        while ((current = current.parentLayerPlan)) {
+            chain = chain + `∈${current.id}`;
+        }
+        const reasonExtra = this.reason.type === "polymorphic"
+            ? `{${this.reason.typeNames.join(",")}}`
+            : "";
+        const deps = this.copyStepIds.length > 0 ? `%${this.copyStepIds}` : "";
+        return `LayerPlan<${this.id}${chain}?${this.reason.type}${reasonExtra}!${this.rootStep?.id ?? "x"}${deps}>`;
+    }
+    print(depth = 0) {
+        const output = [`${" ".repeat(depth * 2)}${this}`];
+        for (const child of this.children) {
+            output.push(child.print(depth + 1));
+        }
+        return output.join("\n");
+    }
+    setRootStep($root) {
+        this.operationPlan.stepTracker.setLayerPlanRootStep(this, $root);
+    }
+    /** @internal Use plan.getStep(id) instead. */
+    getStep(id, requestingStep) {
+        return this.operationPlan.getStep(id, requestingStep);
+    }
+    /** @internal */
+    _addStep(step) {
+        return this.operationPlan._addStep(step);
+    }
+    /** @internal */
+    _addModifierStep(step) {
+        return this.operationPlan._addModifierStep(step);
+    }
+    finalize() {
+        if (this.reason.type === "nullableBoundary" ||
+            this.reason.type === "listItem") {
+            const n = this.copyStepIds.length;
+            const signature = this.reason.type[0] + n;
+            withNewBucketFactory(signature, n, this.reason.type, (fn) => {
+                this.newBucket = fn(this.copyStepIds);
+            });
+        }
+    }
+    newBucket(parentBucket) {
+        const copyStepIds = this.copyStepIds;
+        const store = new Map();
+        const polymorphicPathList = this.reason.type === "mutationField"
+            ? parentBucket.polymorphicPathList
+            : [];
+        const iterators = this.reason.type === "mutationField" ? parentBucket.iterators : [];
+        const map = new Map();
+        let size = 0;
+        switch (this.reason.type) {
+            case "nullableBoundary": {
+                const itemStepId = this.rootStep?.id;
+                assert.ok(itemStepId != null, "GrafastInternalError<f8136364-46c7-4886-b2ae-51319826f97d>: nullableStepStore layer plan has no rootStepId");
+                const nullableStepStore = parentBucket.store.get(itemStepId);
+                if (!nullableStepStore) {
+                    throw new Error(`GrafastInternalError<017dc8bf-1db1-4983-a41e-e69c6652e4c7>: could not find entry '${itemStepId}' (${parentBucket.layerPlan.operationPlan.dangerouslyGetStep(itemStepId)}) in store for ${parentBucket.layerPlan}`);
+                }
+                // PERF: if parent bucket has no nulls/errors in `itemStepId`
+                // then we can just copy everything wholesale rather than building
+                // new arrays and looping.
+                const hasNoNullsOrErrors = false;
+                if (hasNoNullsOrErrors) {
+                    store.set(itemStepId, nullableStepStore);
+                    for (const planId of copyStepIds) {
+                        store.set(planId, parentBucket.store.get(planId));
+                    }
+                    for (let originalIndex = 0; originalIndex < parentBucket.size; originalIndex++) {
+                        const newIndex = size++;
+                        map.set(originalIndex, newIndex);
+                        polymorphicPathList[newIndex] =
+                            parentBucket.polymorphicPathList[originalIndex];
+                        iterators[newIndex] = parentBucket.iterators[originalIndex];
+                    }
+                }
+                else {
+                    const itemStepIdList = [];
+                    store.set(itemStepId, itemStepIdList);
+                    // Prepare store with an empty list for each copyPlanId
+                    for (const planId of copyStepIds) {
+                        store.set(planId, []);
+                    }
+                    // We'll typically be creating fewer nullableBoundary bucket entries
+                    // than we have parent bucket entries (because we exclude nulls), so
+                    // we must "multiply up" (down) the store entries.
+                    for (let originalIndex = 0; originalIndex < parentBucket.size; originalIndex++) {
+                        const fieldValue = nullableStepStore[originalIndex];
+                        if (fieldValue != null) {
+                            const newIndex = size++;
+                            map.set(originalIndex, newIndex);
+                            itemStepIdList[newIndex] = fieldValue;
+                            polymorphicPathList[newIndex] =
+                                parentBucket.polymorphicPathList[originalIndex];
+                            iterators[newIndex] = parentBucket.iterators[originalIndex];
+                            for (const planId of copyStepIds) {
+                                store.get(planId)[newIndex] =
+                                    parentBucket.store.get(planId)[originalIndex];
+                            }
+                        }
+                    }
+                }
+                break;
+            }
+            case "listItem": {
+                const listStepId = this.reason.parentStep.id;
+                const listStepStore = parentBucket.store.get(listStepId);
+                if (!listStepStore) {
+                    throw new Error(`GrafastInternalError<314865b0-f7e8-4e81-b966-56e5a0de562e>: could not find entry '${listStepId}' (${parentBucket.layerPlan.operationPlan.dangerouslyGetStep(listStepId)}) in store for layerPlan ${parentBucket.layerPlan}`);
+                }
+                const itemStepId = this.rootStep?.id;
+                if (itemStepId == null) {
+                    throw new Error("GrafastInternalError<b3a2bff9-15c6-47e2-aa82-19c862324f1a>: listItem layer plan has no rootStepId");
+                }
+                store.set(itemStepId, []);
+                // Prepare store with an empty list for each copyPlanId
+                for (const planId of copyStepIds) {
+                    store.set(planId, []);
+                }
+                // We'll typically be creating more listItem bucket entries than we
+                // have parent buckets, so we must "multiply up" the store entries.
+                for (let originalIndex = 0; originalIndex < parentBucket.size; originalIndex++) {
+                    const list = listStepStore[originalIndex];
+                    if (Array.isArray(list)) {
+                        const newIndexes = [];
+                        map.set(originalIndex, newIndexes);
+                        for (let j = 0, l = list.length; j < l; j++) {
+                            const newIndex = size++;
+                            newIndexes.push(newIndex);
+                            store.get(itemStepId)[newIndex] = list[j];
+                            polymorphicPathList[newIndex] =
+                                parentBucket.polymorphicPathList[originalIndex];
+                            iterators[newIndex] = parentBucket.iterators[originalIndex];
+                            for (const planId of copyStepIds) {
+                                store.get(planId)[newIndex] =
+                                    parentBucket.store.get(planId)[originalIndex];
+                            }
+                        }
+                    }
+                }
+                break;
+            }
+            case "mutationField": {
+                // This is a 1-to-1 map, so we can mostly just copy from parent bucket
+                size = parentBucket.size;
+                for (let i = 0; i < parentBucket.size; i++) {
+                    map.set(i, i);
+                }
+                for (const planId of copyStepIds) {
+                    store.set(planId, parentBucket.store.get(planId));
+                }
+                break;
+            }
+            case "polymorphic": {
+                const polymorphicPlanId = this.reason.parentStep.id;
+                const polymorphicPlanStore = parentBucket.store.get(polymorphicPlanId);
+                if (!polymorphicPlanStore) {
+                    throw new Error(`GrafastInternalError<af1417c6-752b-466e-af7e-cfc35724c3bc>: Entry for '${parentBucket.layerPlan.operationPlan.dangerouslyGetStep(polymorphicPlanId)}' not found in bucket for '${parentBucket.layerPlan}'`);
+                }
+                // We're only copying over the entries that match this type (note:
+                // they may end up being null, but that's okay)
+                const targetTypeNames = this.reason.typeNames;
+                for (const planId of copyStepIds) {
+                    store.set(planId, []);
+                    if (!parentBucket.store.has(planId)) {
+                        throw new Error(`GrafastInternalError<548f0d84-4556-4189-8655-fb16aa3345a6>: new bucket for ${this} wants to copy ${this.operationPlan.dangerouslyGetStep(planId)}, but bucket for ${parentBucket.layerPlan} doesn't contain that plan`);
+                    }
+                }
+                for (let originalIndex = 0; originalIndex < parentBucket.size; originalIndex++) {
+                    const value = polymorphicPlanStore[originalIndex];
+                    if (value == null) {
+                        continue;
+                    }
+                    if ((0, error_js_1.isGrafastError)(value)) {
+                        continue;
+                    }
+                    const typeName = (0, polymorphic_js_1.resolveType)(value);
+                    if (!targetTypeNames.includes(typeName)) {
+                        continue;
+                    }
+                    const newIndex = size++;
+                    map.set(originalIndex, newIndex);
+                    // PERF: might be faster if we look this up as a constant rather than using concatenation here
+                    const newPolymorphicPath = (parentBucket.polymorphicPathList[originalIndex] ?? "") +
+                        ">" +
+                        typeName;
+                    polymorphicPathList[newIndex] = newPolymorphicPath;
+                    iterators[newIndex] = parentBucket.iterators[originalIndex];
+                    for (const planId of copyStepIds) {
+                        store.get(planId)[newIndex] =
+                            parentBucket.store.get(planId)[originalIndex];
+                    }
+                }
+                break;
+            }
+            case "subscription":
+            case "defer": {
+                // TODO
+                throw new Error("TODO");
+            }
+            case "subroutine": {
+                throw new Error("Subroutines are experimental and must currently handle their own bucket creation");
+            }
+            case "root": {
+                throw new Error(
+                // *confused emoji*
+                "GrafastInternalError<05fb7069-81b5-43f7-ae71-f62547d2c2b7>: root cannot be not the root (...)");
+            }
+            default: {
+                const never = this.reason;
+                throw new Error(`GrafastInternalError<8162e6c2-3d66-4d67-ba03-5310a4f9a6d4>: unhandled reason '${(0, inspect_js_1.inspect)(never)}'`);
+            }
+        }
+        if (size > 0) {
+            // Reference
+            const childBucket = (0, executeBucket_js_1.newBucket)({
+                layerPlan: this,
+                size,
+                store,
+                // PERF: not necessarily, if we don't copy the errors, we don't have the errors.
+                hasErrors: parentBucket.hasErrors,
+                polymorphicPathList,
+                iterators,
+            }, parentBucket.metaByMetaKey);
+            parentBucket.children[this.id] = {
+                bucket: childBucket,
+                map,
+            };
+            return childBucket;
+        }
+        else {
+            return null;
+        }
+    }
+}
+exports.LayerPlan = LayerPlan;
+const makeNewBucketCache = new lru_1.default({
+    maxLength: 1000,
+});
+const makingNewBucketCallbacks = new Map();
+const te_parentBucketDotPolymorphicPathList = (0, tamedevil_1.default) `parentBucket.polymorphicPathList`;
+const te_parentBucketDotIterators = (0, tamedevil_1.default) `parentBucket.iterators`;
+const te_emptyArray = (0, tamedevil_1.default) `[]`;
+const ref_newBucket = tamedevil_1.default.ref(executeBucket_js_1.newBucket, "newBucket");
+function makeNewBucketExpression(signature, reasonType, inner) {
+    return (0, tamedevil_1.default) `\
+(function ${tamedevil_1.default.identifier(`newBucket_${signature}`)}(parentBucket) {
+  const store = new Map();
+  const polymorphicPathList = ${reasonType === "mutationField"
+        ? te_parentBucketDotPolymorphicPathList
+        : te_emptyArray};
+  const iterators = ${reasonType === "mutationField" ? te_parentBucketDotIterators : te_emptyArray};
+  const map = new Map();
+  let size = 0;
+
+${inner}
+
+  if (size > 0) {
+    // Reference
+    const childBucket = ${ref_newBucket}({
+      layerPlan: this,
+      size,
+      store,
+      // PERF: not necessarily, if we don't copy the errors, we don't have the errors.
+      hasErrors: parentBucket.hasErrors,
+      polymorphicPathList,
+      iterators,
+    }, parentBucket.metaByMetaKey);
+    // PERF: set ourselves in more places so that we never have to call 'getChildBucketAndIndex'.
+    parentBucket.children[this.id] = { bucket: childBucket, map };
+
+    return childBucket;
+  } else {
+    return null;
+  }
+})`;
+}
+function newBucketFactoryInnerExpression(signature, copyCount, reasonType) {
+    if (reasonType === "nullableBoundary") {
+        // PERF: if parent bucket has no nulls/errors in itemStepId
+        // then we can just copy everything wholesale rather than building
+        // new arrays and looping.
+        const blocks = [];
+        const copyBlocks = [];
+        for (let i = 0; i < copyCount; i++) {
+            const te_source = tamedevil_1.default.identifier(`source${i}`);
+            const te_target = tamedevil_1.default.identifier(`target${i}`);
+            const te_i = tamedevil_1.default.lit(i);
+            blocks.push((0, tamedevil_1.default) `\
+  const ${te_source} = parentBucket.store.get(copyPlanIds[${te_i}]);
+  const ${te_target} = [];
+  store.set(copyPlanIds[${te_i}], ${te_target});
+`);
+            copyBlocks.push((0, tamedevil_1.default) `\
+      ${te_target}[newIndex] = ${te_source}[originalIndex];
+`);
+        }
+        return makeNewBucketExpression(signature, reasonType, (0, tamedevil_1.default) `\
+  const itemStepId = this.rootStep.id;
+  const nullableStepStore = parentBucket.store.get(itemStepId);
+
+  const itemStepIdList = [];
+  store.set(itemStepId, itemStepIdList);
+
+  // Prepare store with an empty list for each copyPlanId
+${tamedevil_1.default.join(blocks, "")}
+
+  // We'll typically be creating fewer nullableBoundary bucket entries
+  // than we have parent bucket entries (because we exclude nulls), so
+  // we must "multiply up" (down) the store entries.
+  for (
+    let originalIndex = 0;
+    originalIndex < parentBucket.size;
+    originalIndex++
+  ) {
+    const fieldValue = nullableStepStore[originalIndex];
+    if (fieldValue != null) {
+      const newIndex = size++;
+      map.set(originalIndex, newIndex);
+      itemStepIdList[newIndex] = fieldValue;
+
+      polymorphicPathList[newIndex] = parentBucket.polymorphicPathList[originalIndex];
+      iterators[newIndex] = parentBucket.iterators[originalIndex];
+${tamedevil_1.default.join(copyBlocks, "")}
+    }
+  }
+`);
+    }
+    else if (reasonType === "listItem") {
+        const blocks = [];
+        const copyBlocks = [];
+        for (let i = 0; i < copyCount; i++) {
+            const te_source = tamedevil_1.default.identifier(`source${i}`);
+            const te_target = tamedevil_1.default.identifier(`target${i}`);
+            const te_i = tamedevil_1.default.lit(i);
+            blocks.push((0, tamedevil_1.default) `\
+  const ${te_source} = parentBucket.store.get(copyPlanIds[${te_i}]);
+  const ${te_target} = [];
+  store.set(copyPlanIds[${te_i}], ${te_target});
+  `);
+            copyBlocks.push((0, tamedevil_1.default) `\
+        ${te_target}[newIndex] = ${te_source}[originalIndex];
+        `);
+        }
+        return makeNewBucketExpression(signature, reasonType, (0, tamedevil_1.default) `\
+  const listStepStore = parentBucket.store.get(this.reason.parentStep.id);
+
+  const itemStepIdList = [];
+  store.set(this.rootStep.id, itemStepIdList);
+
+  // Prepare store with an empty list for each copyPlanId
+  ${tamedevil_1.default.join(blocks, "")}
+
+  // We'll typically be creating more listItem bucket entries than we
+  // have parent buckets, so we must "multiply up" the store entries.
+  for (
+    let originalIndex = 0;
+    originalIndex < parentBucket.size;
+    originalIndex++
+  ) {
+    const list = listStepStore[originalIndex];
+    if (Array.isArray(list)) {
+      const newIndexes = [];
+      map.set(originalIndex, newIndexes);
+      for (let j = 0, l = list.length; j < l; j++) {
+        const newIndex = size++;
+        newIndexes.push(newIndex);
+        itemStepIdList[newIndex] = list[j];
+
+        polymorphicPathList[newIndex] = parentBucket.polymorphicPathList[originalIndex];
+        iterators[newIndex] = parentBucket.iterators[originalIndex];
+        ${tamedevil_1.default.join(copyBlocks, "")}
+      }
+    }
+  }
+
+`);
+    }
+    else {
+        const never = reasonType;
+        return never;
+    }
+}
+function withNewBucketFactory(signature, copyCount, reasonType, callback) {
+    const fn = makeNewBucketCache.get(signature);
+    if (fn !== undefined) {
+        return callback(fn);
+    }
+    const building = makingNewBucketCallbacks.get(signature);
+    if (building !== undefined) {
+        building.push(callback);
+        return;
+    }
+    const callbacks = [callback];
+    makingNewBucketCallbacks.set(signature, callbacks);
+    const executorExpression = newBucketFactoryInnerExpression(signature, copyCount, reasonType);
+    const factoryExpression = (0, tamedevil_1.default) `\
+function ${tamedevil_1.default.identifier(`layerPlanNewBucketFactory_${signature}`)}(copyPlanIds) {
+  return ${executorExpression};
+}`;
+    tamedevil_1.default.runInBatch(factoryExpression, (factory) => {
+        makeNewBucketCache.set(signature, factory);
+        makingNewBucketCallbacks.delete(signature);
+        for (const callback of callbacks) {
+            callback(factory);
+        }
+    });
+}
+//# sourceMappingURL=LayerPlan.js.map