grafast 0.1.1-beta.5 → 0.1.1-beta.7

package/README.md

@@ -55,6 +55,7 @@ And please give some love to our featured sponsors 🤩:
 <td align="center"><a href="https://stellate.co/"><img src="https://graphile.org/images/sponsors/Stellate.png" width="90" height="90" alt="Stellate" /><br />Stellate</a> *</td>
 </tr><tr>
 <td align="center"><a href="https://gosteelhead.com/"><img src="https://graphile.org/images/sponsors/steelhead.svg" width="90" height="90" alt="Steelhead" /><br />Steelhead</a> *</td>
+<td align="center"><a href="https://www.sylvera.com/"><img src="https://graphile.org/images/sponsors/sylvera.svg" width="90" height="90" alt="Sylvera" /><br />Sylvera</a> *</td>
 </tr></table>
 
 <em>\* Sponsors the entire Graphile suite</em>

package/dist/dev.d.ts

@@ -1,2 +1,3 @@
+export declare const isTest: boolean;
 export declare function noop(): void;
 //# sourceMappingURL=dev.d.ts.map

package/dist/dev.js

@@ -1,10 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.noop = exports.isDev = void 0;
+exports.noop = exports.isTest = 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;
+const mode = graphileEnv !== undefined ? graphileEnv : nodeEnv;
+/**
+ * @internal
+ */
+exports.isDev = mode === "development" || mode === "test";
+exports.isTest = mode === "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 && !exports.isTest) {
+    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/LayerPlan.js

@@ -5,8 +5,8 @@ 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 interfaces_js_1 = require("../interfaces.js");
 const polymorphic_js_1 = require("../polymorphic.js");
 const executeBucket_js_1 = require("./executeBucket.js");
 function isBranchingLayerPlan(layerPlan) {
@@ -76,8 +76,8 @@ class LayerPlan {
          */
         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
+         * Which steps the results for which are available in a parent bucket need to
+         * be "copied across" to this bucket because steps in this bucket still
          * reference them?
          *
          * @internal
@@ -132,7 +132,7 @@ class LayerPlan {
         const reasonExtra = this.reason.type === "polymorphic"
             ? `{${this.reason.typeNames.join(",")}}`
             : "";
-        const deps = this.copyStepIds.length > 0 ? `%${this.copyStepIds}` : "";
+        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) {
@@ -158,17 +158,18 @@ class LayerPlan {
         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) => {
+        if (
+        // this.reason.type === "nullableBoundary" ||
+        this.reason.type === "listItem") {
+            const u = this.copyStepIds.length;
+            const signature = `${this.reason.type[0]}_${u}`;
+            withNewBucketFactory(signature, u, this.reason.type, (fn) => {
                 this.newBucket = fn(this.copyStepIds);
             });
         }
     }
     newBucket(parentBucket) {
-        const copyStepIds = this.copyStepIds;
+        const { copyStepIds } = this;
         const store = new Map();
         const polymorphicPathList = this.reason.type === "mutationField"
             ? parentBucket.polymorphicPathList
@@ -178,20 +179,41 @@ class LayerPlan {
         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}`);
+                if (this.rootStep == null) {
+                    throw new Error("GrafastInternalError<f8136364-46c7-4886-b2ae-51319826f97d>: nullableStepStore layer plan has no rootStepId");
                 }
+                const itemStepId = this.rootStep.id;
                 // 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) {
+                if (this.rootStep._isUnary) {
+                    const fieldValue = parentBucket.store.get(itemStepId);
+                    const forbiddenFlags = fieldValue._entryFlags & interfaces_js_1.FORBIDDEN_BY_NULLABLE_BOUNDARY_FLAGS;
+                    if (forbiddenFlags) {
+                        size = 0;
+                    }
+                    else {
+                        size = parentBucket.size;
+                        store.set(itemStepId, fieldValue);
+                        for (const stepId of copyStepIds) {
+                            store.set(stepId, parentBucket.store.get(stepId));
+                        }
+                        for (let i = 0; i < size; i++) {
+                            map.set(i, i);
+                            polymorphicPathList[i] = parentBucket.polymorphicPathList[i];
+                            iterators[i] = parentBucket.iterators[i];
+                        }
+                    }
+                }
+                else if (hasNoNullsOrErrors) {
+                    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}`);
+                    }
                     store.set(itemStepId, nullableStepStore);
-                    for (const planId of copyStepIds) {
-                        store.set(planId, parentBucket.store.get(planId));
+                    for (const stepId of copyStepIds) {
+                        store.set(stepId, parentBucket.store.get(stepId));
                     }
                     for (let originalIndex = 0; originalIndex < parentBucket.size; originalIndex++) {
                         const newIndex = size++;
@@ -203,16 +225,26 @@ class LayerPlan {
                 }
                 else {
                     const itemStepIdList = [];
-                    store.set(itemStepId, itemStepIdList);
-                    // Prepare store with an empty list for each copyPlanId
-                    for (const planId of copyStepIds) {
-                        store.set(planId, []);
+                    store.set(itemStepId, (0, executeBucket_js_1.batchExecutionValue)(itemStepIdList));
+                    for (const stepId of copyStepIds) {
+                        const ev = parentBucket.store.get(stepId);
+                        if (ev.isBatch) {
+                            // Prepare store with an empty list for each copyPlanId
+                            store.set(stepId, (0, executeBucket_js_1.batchExecutionValue)([]));
+                        }
+                        else {
+                            store.set(stepId, ev);
+                        }
+                    }
+                    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}`);
                     }
                     // 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];
+                        const fieldValue = nullableStepStore.at(originalIndex);
                         if (fieldValue != null) {
                             const newIndex = size++;
                             map.set(originalIndex, newIndex);
@@ -220,9 +252,12 @@ class LayerPlan {
                             polymorphicPathList[newIndex] =
                                 parentBucket.polymorphicPathList[originalIndex];
                             iterators[newIndex] = parentBucket.iterators[originalIndex];
-                            for (const planId of copyStepIds) {
-                                store.get(planId)[newIndex] =
-                                    parentBucket.store.get(planId)[originalIndex];
+                            for (const stepId of copyStepIds) {
+                                const ev = store.get(stepId);
+                                if (ev.isBatch) {
+                                    const orig = parentBucket.store.get(stepId);
+                                    ev._copyResult(newIndex, orig, originalIndex);
+                                }
                             }
                         }
                     }
@@ -235,32 +270,52 @@ class LayerPlan {
                 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) {
+                if (this.rootStep == 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, []);
+                const itemStepId = this.rootStep.id;
+                // Item steps are **NOT** unary
+                const itemStepIdList = this.rootStep._isUnary ? null : [];
+                if (this.rootStep._isUnary) {
+                    // handled later
+                    const list = listStepStore.at(0);
+                    store.set(itemStepId, (0, executeBucket_js_1.unaryExecutionValue)(Array.isArray(list) ? list[0] : list));
+                }
+                else {
+                    store.set(itemStepId, (0, executeBucket_js_1.batchExecutionValue)(itemStepIdList));
+                }
+                for (const stepId of copyStepIds) {
+                    const ev = parentBucket.store.get(stepId);
+                    if (ev.isBatch) {
+                        // Prepare store with an empty list for each copyPlanId
+                        store.set(stepId, (0, executeBucket_js_1.batchExecutionValue)([]));
+                    }
+                    else {
+                        store.set(stepId, ev);
+                    }
                 }
                 // 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];
+                    const list = listStepStore.at(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];
+                            if (itemStepIdList !== null) {
+                                itemStepIdList[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];
+                            for (const stepId of copyStepIds) {
+                                const ev = store.get(stepId);
+                                if (ev.isBatch) {
+                                    const orig = parentBucket.store.get(stepId);
+                                    ev._copyResult(newIndex, orig, originalIndex);
+                                }
                             }
                         }
                     }
@@ -273,8 +328,8 @@ class LayerPlan {
                 for (let i = 0; i < parentBucket.size; i++) {
                     map.set(i, i);
                 }
-                for (const planId of copyStepIds) {
-                    store.set(planId, parentBucket.store.get(planId));
+                for (const stepId of copyStepIds) {
+                    store.set(stepId, parentBucket.store.get(stepId));
                 }
                 break;
             }
@@ -287,20 +342,24 @@ class 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 (const stepId of copyStepIds) {
+                    const ev = parentBucket.store.get(stepId);
+                    if (!ev) {
+                        throw new Error(`GrafastInternalError<548f0d84-4556-4189-8655-fb16aa3345a6>: new bucket for ${this} wants to copy ${this.operationPlan.dangerouslyGetStep(stepId)}, but bucket for ${parentBucket.layerPlan} doesn't contain that plan`);
+                    }
+                    if (ev.isBatch) {
+                        store.set(stepId, (0, executeBucket_js_1.batchExecutionValue)([]));
+                    }
+                    else {
+                        store.set(stepId, ev);
                     }
                 }
                 for (let originalIndex = 0; originalIndex < parentBucket.size; originalIndex++) {
-                    const value = polymorphicPlanStore[originalIndex];
-                    if (value == null) {
-                        continue;
-                    }
-                    if ((0, error_js_1.isGrafastError)(value)) {
+                    const flags = polymorphicPlanStore._flagsAt(originalIndex);
+                    if (flags & (interfaces_js_1.FLAG_ERROR | interfaces_js_1.FLAG_INHIBITED | interfaces_js_1.FLAG_NULL)) {
                         continue;
                     }
+                    const value = polymorphicPlanStore.at(originalIndex);
                     const typeName = (0, polymorphic_js_1.resolveType)(value);
                     if (!targetTypeNames.includes(typeName)) {
                         continue;
@@ -314,8 +373,11 @@ class LayerPlan {
                     polymorphicPathList[newIndex] = newPolymorphicPath;
                     iterators[newIndex] = parentBucket.iterators[originalIndex];
                     for (const planId of copyStepIds) {
-                        store.get(planId)[newIndex] =
-                            parentBucket.store.get(planId)[originalIndex];
+                        const ev = store.get(planId);
+                        if (ev.isBatch) {
+                            const orig = parentBucket.store.get(planId);
+                            ev._copyResult(newIndex, orig, originalIndex);
+                        }
                     }
                 }
                 break;
@@ -345,7 +407,7 @@ class LayerPlan {
                 size,
                 store,
                 // PERF: not necessarily, if we don't copy the errors, we don't have the errors.
-                hasErrors: parentBucket.hasErrors,
+                flagUnion: parentBucket.flagUnion,
                 polymorphicPathList,
                 iterators,
             }, parentBucket.metaByMetaKey);
@@ -369,8 +431,9 @@ const te_parentBucketDotPolymorphicPathList = (0, tamedevil_1.default) `parentBu
 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");
+const ref_batchExecutionValue = tamedevil_1.default.ref(executeBucket_js_1.batchExecutionValue, "batchExecutionValue");
 function makeNewBucketExpression(signature, reasonType, inner) {
-    return (0, tamedevil_1.default) `\
+    const expr = (0, tamedevil_1.default) `\
 (function ${tamedevil_1.default.identifier(`newBucket_${signature}`)}(parentBucket) {
   const store = new Map();
   const polymorphicPathList = ${reasonType === "mutationField"
@@ -389,7 +452,7 @@ ${inner}
       size,
       store,
       // PERF: not necessarily, if we don't copy the errors, we don't have the errors.
-      hasErrors: parentBucket.hasErrors,
+      flagUnion: parentBucket.flagUnion,
       polymorphicPathList,
       iterators,
     }, parentBucket.metaByMetaKey);
@@ -401,9 +464,14 @@ ${inner}
     return null;
   }
 })`;
+    // te.debug(expr);
+    return expr;
 }
 function newBucketFactoryInnerExpression(signature, copyCount, reasonType) {
     if (reasonType === "nullableBoundary") {
+        if (Math.random() < 2) {
+            throw new Error("This code no longer works since we added unary steps.");
+        }
         // PERF: if parent bucket has no nulls/errors in itemStepId
         // then we can just copy everything wholesale rather than building
         // new arrays and looping.
@@ -414,12 +482,14 @@ function newBucketFactoryInnerExpression(signature, copyCount, reasonType) {
             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});
+  const ${te_source} = parentBucket.store.get(copyStepIds[${te_i}]);
+  const ${te_target} = ${te_source}.isBatch ? ${ref_batchExecutionValue}([]) : ${te_source};
+  store.set(copyStepIds[${te_i}], ${te_target});
 `);
             copyBlocks.push((0, tamedevil_1.default) `\
-      ${te_target}[newIndex] = ${te_source}[originalIndex];
+      if(${te_target}.isBatch) {
+        ${te_target}.entries[newIndex] = ${te_source}.at(originalIndex);
+      }
 `);
         }
         return makeNewBucketExpression(signature, reasonType, (0, tamedevil_1.default) `\
@@ -427,7 +497,7 @@ function newBucketFactoryInnerExpression(signature, copyCount, reasonType) {
   const nullableStepStore = parentBucket.store.get(itemStepId);
 
   const itemStepIdList = [];
-  store.set(itemStepId, itemStepIdList);
+  store.set(itemStepId, ${ref_batchExecutionValue}(itemStepIdList));
 
   // Prepare store with an empty list for each copyPlanId
 ${tamedevil_1.default.join(blocks, "")}
@@ -440,7 +510,7 @@ ${tamedevil_1.default.join(blocks, "")}
     originalIndex < parentBucket.size;
     originalIndex++
   ) {
-    const fieldValue = nullableStepStore[originalIndex];
+    const fieldValue = nullableStepStore.at(originalIndex);
     if (fieldValue != null) {
       const newIndex = size++;
       map.set(originalIndex, newIndex);
@@ -461,19 +531,22 @@ ${tamedevil_1.default.join(copyBlocks, "")}
             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});
+  const ${te_source} = parentBucket.store.get(copyStepIds[${te_i}]);
+  const ${te_target} = ${te_source}.isBatch ? ${ref_batchExecutionValue}([]) : ${te_source};
+  store.set(copyStepIds[${te_i}], ${te_target});
   `);
             copyBlocks.push((0, tamedevil_1.default) `\
-        ${te_target}[newIndex] = ${te_source}[originalIndex];
+        if (${te_target}.isBatch) {
+          ${te_target}.entries[newIndex] = ${te_source}.at(originalIndex);
+        }
         `);
         }
         return makeNewBucketExpression(signature, reasonType, (0, tamedevil_1.default) `\
-  const listStepStore = parentBucket.store.get(this.reason.parentStep.id);
+  const listStepId = this.reason.parentStep.id;
+  const listStepStore = parentBucket.store.get(listStepId);
 
   const itemStepIdList = [];
-  store.set(this.rootStep.id, itemStepIdList);
+  store.set(this.rootStep.id, ${ref_batchExecutionValue}(itemStepIdList));
 
   // Prepare store with an empty list for each copyPlanId
   ${tamedevil_1.default.join(blocks, "")}
@@ -485,7 +558,7 @@ ${tamedevil_1.default.join(copyBlocks, "")}
     originalIndex < parentBucket.size;
     originalIndex++
   ) {
-    const list = listStepStore[originalIndex];
+    const list = listStepStore.at(originalIndex);
     if (Array.isArray(list)) {
       const newIndexes = [];
       map.set(originalIndex, newIndexes);
@@ -522,7 +595,7 @@ function withNewBucketFactory(signature, copyCount, reasonType, 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) {
+function ${tamedevil_1.default.identifier(`layerPlanNewBucketFactory_${signature}`)}(copyStepIds) {
   return ${executorExpression};
 }`;
     tamedevil_1.default.runInBatch(factoryExpression, (factory) => {

package/dist/engine/OperationPlan.d.ts

@@ -175,6 +175,7 @@ export declare class OperationPlan {
      * know all our dependent's needs before we optimise ourself.
      */
     private optimizeSteps;
+    private inlineSteps;
     /** Finalizes each step */
     private finalizeSteps;
     private finalizeLayerPlans;