grafast 1.0.0-rc.6 → 1.0.0-rc.7

package/dist/engine/LayerPlan.js

@@ -16,12 +16,17 @@ const executeBucket_ts_1 = require("./executeBucket.js");
  * If any of these flags exist on a value then it isn't the value we want to
  * include for the combo step.
  */
-const SKIP_FLAGS = constants_ts_1.FLAG_ERROR | constants_ts_1.FLAG_STOPPED | constants_ts_1.FLAG_POLY_SKIPPED | constants_ts_1.FLAG_INHIBITED;
+const SKIP_FLAGS = constants_ts_1.FLAG_ERROR | constants_ts_1.FLAG_STOPPED | constants_ts_1.FLAG_POLY_SKIPPED | constants_ts_1.FLAG_INHIBITED | constants_ts_1.FLAG_NULL;
 /**
  * If any of these flags exist on the "$__typename" step, then the value
  * should resolve to null
  */
 const NO_TYPENAME_FLAGS = constants_ts_1.FLAG_ERROR | constants_ts_1.FLAG_STOPPED | constants_ts_1.FLAG_POLY_SKIPPED | constants_ts_1.FLAG_INHIBITED | constants_ts_1.FLAG_NULL;
+/**
+ * Used to determine if we should copy the error. Should only be copied if it's
+ * NOT polymorphic skipped; so we check the result `=== FLAG_ERROR`
+ */
+const ERROR_OR_POLY_SKIPPED_FLAGS = constants_ts_1.FLAG_ERROR | constants_ts_1.FLAG_POLY_SKIPPED;
 function hasParentLayerPlan(reason) {
     return reason.type !== "root" && reason.type !== "combined";
 }
@@ -298,6 +303,7 @@ class LayerPlan {
         const polymorphicType = this.reason.type === "polymorphic" ? [] : null;
         const iterators = this.reason.type === "mutationField" ? parentBucket.iterators : [];
         const map = new Map();
+        let flagUnion = parentBucket.flagUnion;
         const $parentSideEffect = this.parentSideEffectStep;
         let parentSideEffectValue;
         if ($parentSideEffect) {
@@ -476,6 +482,7 @@ class LayerPlan {
                                     flags = flags | constants_ts_1.FLAG_NULL;
                                 }
                             }
+                            flagUnion |= flags;
                             ev._setResult(newIndex, val, flags);
                             polymorphicPathList[newIndex] =
                                 parentBucket.polymorphicPathList[originalIndex];
@@ -640,7 +647,7 @@ class LayerPlan {
                 size,
                 store,
                 // PERF: not necessarily, if we don't copy the errors, we don't have the errors.
-                flagUnion: parentBucket.flagUnion,
+                flagUnion,
                 polymorphicPathList,
                 polymorphicType,
                 iterators,
@@ -669,6 +676,8 @@ class LayerPlan {
             return null;
         }
     }
+    // TODO: currently we copy nulls and errors through. Ideally we wouldn't,
+    // thereby shrinking the size of the bucket.
     newCombinedBucket(finalParentBucket) {
         const t = this.reason.type;
         if (t !== "combined") {
@@ -753,6 +762,7 @@ class LayerPlan {
                     continue;
                 for (let originalIndex = 0; originalIndex < parentBucket.size; originalIndex++) {
                     const newIndex = originalIndex + offset;
+                    let fallbackErrorSource = null;
                     if (sourceStepsByLayerPlanId[plp.id]) {
                         for (const stepId of sourceStepsByLayerPlanId[plp.id]) {
                             const sourceStore = parentBucket.store.get(stepId);
@@ -760,12 +770,29 @@ class LayerPlan {
                                 const step = this.operationPlan.stepTracker.getStepById(stepId);
                                 throw new Error(`GrafastInternalError<a48ca88c-e4b9-4a4f-9a38-846fa067f143>: missing source store for ${step} (${stepId}) in ${this}`);
                             }
-                            if ((sourceStore._flagsAt(originalIndex) & SKIP_FLAGS) == 0) {
+                            const sourceFlags = sourceStore._flagsAt(originalIndex);
+                            if ((sourceFlags & SKIP_FLAGS) === 0) {
                                 ev._copyResult(newIndex, sourceStore, originalIndex);
+                                fallbackErrorSource = null;
                                 break;
                             }
+                            else if (fallbackErrorSource === null &&
+                                (sourceFlags & ERROR_OR_POLY_SKIPPED_FLAGS) === constants_ts_1.FLAG_ERROR) {
+                                fallbackErrorSource = sourceStore;
+                            } // If no matches, it retains `FLAG_NULL | FLAG_STOPPED` from above
                         }
                     }
+                    if (fallbackErrorSource !== null) {
+                        // No non-skipped source existed for this index; preserve the first
+                        // available error instead of silently converting to stopped/null.
+                        //
+                        // Normally we'd do:
+                        //
+                        //     ev._copyResult(newIndex, fallbackErrorSource, originalIndex);
+                        //
+                        // However, we want to add FLAG_STOPPED, so we do this manually:
+                        ev._setResult(newIndex, fallbackErrorSource.at(originalIndex), fallbackErrorSource._flagsAt(originalIndex) | constants_ts_1.FLAG_STOPPED);
+                    }
                     iterators[newIndex] = parentBucket.iterators[originalIndex];
                 }
                 offset += parentBucket.size;

package/dist/engine/OperationPlan.js

@@ -1220,6 +1220,9 @@ class OperationPlan {
                             : (0, step_ts_1.stepHasToRecord)($original)
                                 ? (0, withGlobalLayerPlan_ts_1.withGlobalLayerPlan)(commonLayerPlan, polymorphicPaths, planningPath, null, $original.toRecord, $original)
                                 : $original;
+                    // Combo layer plan filters nulls for us; since we're skipping that
+                    // we need to explicitly inhibit nulls
+                    commonStep = (0, withGlobalLayerPlan_ts_1.withGlobalLayerPlan)(commonLayerPlan, polymorphicPaths, planningPath, null, index_ts_1.inhibitOnNull, null, commonStep);
                     for (const detailsRecord of detailsRecordList) {
                         detailsRecord.layerPlan = commonLayerPlan;
                         const polymorphicPaths = detailsRecord.polymorphicPaths;

package/dist/engine/distributor.js

@@ -147,7 +147,7 @@ function distributor(sourceIterable, dependentSteps, abortSignal, distributorOpt
             let advanced = false;
             while (smallest >= lowWaterMark) {
                 advanced = true;
-                buffer.shift();
+                void buffer.shift();
                 lowWaterMark++;
             }
             // Announce that the lowWaterMark advanced
@@ -342,14 +342,14 @@ function distributor(sourceIterable, dependentSteps, abortSignal, distributorOpt
             const stepIndex = getStepIndex(stepId);
             if (!hasIterator[stepIndex]) {
                 hasIterator[stepIndex] = true;
-                stop(stepIndex);
+                void stop(stepIndex);
             }
         },
     };
     abortSignal.addEventListener("abort", () => {
         for (let stepIndex = 0, l = dependentSteps.length; stepIndex < l; stepIndex++) {
             hasIterator[stepIndex] = true;
-            stop(stepIndex, undefined, false);
+            void stop(stepIndex, undefined, false);
         }
         maybeAdvanceLowWaterMark();
     });

package/dist/engine/executeBucket.js

@@ -181,9 +181,7 @@ function executeBucket(bucket, requestContext) {
             // **DO NOT THROW, DO NOT ALLOW AN ERROR TO BE RAISED!**
             // **USE DEFENSIVE PROGRAMMING HERE!**
             /** PROMISES ADDED HERE MUST NOT REJECT */
-            let promises;
-            let pendingPromises;
-            let pendingPromiseIndexes;
+            let promises = undefined;
             // TODO: it seems that if this throws an error it results in a permanent
             // hang of defers? In the mean time... Don't throw any errors here!
             const success = (finishedStep, bucket, resultIndex, rawValue, flags) => {
@@ -234,8 +232,9 @@ function executeBucket(bucket, requestContext) {
                             }
                             replacement[i] = null;
                             const index = i;
+                            // Must not reject
                             const promise = item.then((v) => void (replacement[index] = v), (e) => void (replacement[index] = (0, error_ts_1.flagError)(e)));
-                            if (!promises) {
+                            if (promises === undefined) {
                                 promises = [promise];
                             }
                             else {
@@ -343,7 +342,7 @@ function executeBucket(bucket, requestContext) {
                                 bucket.setResult(finishedStep, resultIndex, e, flags | constants_ts_1.FLAG_ERROR);
                             }
                         })();
-                        if (!promises) {
+                        if (promises === undefined) {
                             promises = [promise];
                         }
                         else {
@@ -365,56 +364,26 @@ function executeBucket(bucket, requestContext) {
                 const count = step._isUnary ? 1 : size;
                 for (let dataIndex = 0; dataIndex < count; dataIndex++) {
                     const val = results[dataIndex];
+                    const valFlags = flags[dataIndex];
+                    if (valFlags == null) {
+                        throw new Error(`GraphileInternalError<75df71bb-0f76-4a98-9664-9167d502296a>: result for ${step} has no flag at index ${dataIndex} (value = ${(0, inspect_ts_1.inspect)(val)})`);
+                    }
                     if (step.isSyncAndSafe || !(0, utils_ts_1.isPromiseLike)(val)) {
-                        if (flags[dataIndex] == null) {
-                            throw new Error(`GraphileInternalError<75df71bb-0f76-4a98-9664-9167d502296a>: result for ${step} has no flag at index ${dataIndex} (value = ${(0, inspect_ts_1.inspect)(val)})`);
-                        }
-                        success(step, bucket, dataIndex, val, flags[dataIndex]);
+                        success(step, bucket, dataIndex, val, valFlags);
                     }
                     else {
-                        if (!pendingPromises) {
-                            pendingPromises = [val];
-                            pendingPromiseIndexes = [{ s: allStepsIndex, i: dataIndex }];
+                        // Must not reject!
+                        const valSuccess = val.then((val) => success(step, bucket, dataIndex, val, valFlags), (error) => bucket.setResult(step, dataIndex, error, constants_ts_1.FLAG_ERROR));
+                        if (promises === undefined) {
+                            promises = [valSuccess];
                         }
                         else {
-                            pendingPromises.push(val);
-                            pendingPromiseIndexes.push({ s: allStepsIndex, i: dataIndex });
+                            promises.push(valSuccess);
                         }
                     }
                 }
             }
-            if (pendingPromises !== undefined) {
-                return Promise.allSettled(pendingPromises)
-                    .then((resultSettledResult) => {
-                    for (let i = 0, pendingPromisesLength = resultSettledResult.length; i < pendingPromisesLength; i++) {
-                        const settledResult = resultSettledResult[i];
-                        const { s: allStepsIndex, i: dataIndex } = pendingPromiseIndexes[i];
-                        const finishedStep = _allSteps[allStepsIndex];
-                        if (settledResult.status === "fulfilled") {
-                            success(finishedStep, bucket, dataIndex, settledResult.value, constants_ts_1.NO_FLAGS);
-                        }
-                        else {
-                            const error = settledResult.reason;
-                            bucket.setResult(finishedStep, dataIndex, error, constants_ts_1.FLAG_ERROR);
-                        }
-                    }
-                    return promises ? Promise.all(promises) : undefined;
-                })
-                    .then(null, (e) => {
-                    // THIS SHOULD NEVER HAPPEN!
-                    console.error(`GrafastInternalError<1e9731b4-005e-4b0e-bc61-43baa62e6444>: this error should never occur! Please file an issue against grafast. Details: ${e}`);
-                    bucket.flagUnion |= constants_ts_1.FLAG_ERROR;
-                    for (let i = 0, pendingPromisesLength = pendingPromises.length; i < pendingPromisesLength; i++) {
-                        const { s: allStepsIndex, i: dataIndex } = pendingPromiseIndexes[i];
-                        const finishedStep = _allSteps[allStepsIndex];
-                        const error = new Error(`GrafastInternalError<1e9731b4-005e-4b0e-bc61-43baa62e6444>: error occurred whilst performing completedStep(${finishedStep.id})`);
-                        bucket.setResult(finishedStep, dataIndex, error, constants_ts_1.FLAG_ERROR);
-                    }
-                });
-            }
-            else {
-                return promises ? Promise.all(promises) : undefined;
-            }
+            return promises === undefined ? undefined : Promise.all(promises);
         };
         const runSyncSteps = () => {
             const executedLength = resultList.length;
@@ -1046,14 +1015,22 @@ function markLayerPlanAsDone(requestContext, sharedState, layerPlan, bucket) {
                 if (!allParentLayerPlansAreReady) {
                     // The last parent layer plan to complete will handle it.
                     // Make sure we're retained so it can use our data!
-                    // Will be released inside the "combined" branch in childLayerPlan.newBucket
+                    // Released below.
                     if (bucket != null) {
                         bucket.sharedState.retain(bucket);
                     }
-                    // TODO: MAKE SURE CANCELLED BUCKETS ARE HANDLED!
                     continue loop;
                 }
                 const childBucket = childLayerPlan.newCombinedBucket({ sharedState });
+                // Every parent except the final parent was retained while waiting for all
+                // parents to complete; release those temporary retains now.
+                for (const plp of childLayerPlan.reason.parentLayerPlans) {
+                    if (plp === layerPlan)
+                        continue; // Was never retained
+                    const otherBucket = sharedState._retainedBuckets.get(plp.id);
+                    if (otherBucket !== undefined)
+                        sharedState.release(otherBucket);
+                }
                 if (childBucket !== null) {
                     // Execute
                     const result = executeBucket(childBucket, requestContext);
@@ -1174,9 +1151,7 @@ function newBucket(parent, spec) {
             if (index >= size) {
                 throw new Error(`GrafastInternalError<9465db89-cc9d-415c-97e7-57bb19ddebe0>: attempt to write to out of bounds index ${index} for bucket of size ${size} for step ${step}`);
             }
-            if (flags !== constants_ts_1.NO_FLAGS) {
-                this.flagUnion |= flags;
-            }
+            this.flagUnion |= flags;
             if (step._isUnary) {
                 if (dev_ts_1.isDev && store.has(stepId)) {
                     const ev = store.get(stepId);

package/dist/steps/_loadCommon.js

@@ -171,7 +171,7 @@ function executeLoad(details, sharedDepId, paramDepIdByKey, baseLoadInfo, load)
             (0, exports.nextTick)(() => {
                 // Don't allow adding anything else to the batch
                 meta.loadBatchesByLoad.delete(load);
-                executeBatches(loadBatches, loadInfo, load);
+                void executeBatches(loadBatches, loadInfo, load);
             });
         }
         return (async () => {

package/dist/steps/graphqlResolver.js

@@ -66,10 +66,10 @@ class GraphQLResolverStep extends step_ts_1.UnbatchedStep {
         }
         else {
             if (this.isNotRoot) {
-                return Promise.reject(new Error(`Invalid non-root subscribe`));
+                return (0, index_ts_1.flagError)(new Error(`Invalid non-root subscribe`));
             }
             if (this.subscriber == null) {
-                return Promise.reject(new Error(`Cannot subscribe to field`));
+                return (0, index_ts_1.flagError)(new Error(`Cannot subscribe to field`));
             }
             const resolveInfo = Object.assign(Object.create(this.resolveInfoBase), {
                 // ENHANCE: add support for path
@@ -119,6 +119,8 @@ class GraphQLResolveTypeStep extends step_ts_1.Step {
      * resolution part.
      */
     figureOutTheTypeOf(data, context, resolveInfo) {
+        if (data == null)
+            return data;
         const abstractType = this.abstractType;
         if (abstractType.resolveType != null) {
             return abstractType.resolveType(data, context, resolveInfo, abstractType);

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "1.0.0-rc.6";
+export declare const version = "1.0.0-rc.7";
 //# 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 = "1.0.0-rc.6";
+exports.version = "1.0.0-rc.7";
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grafast",
-  "version": "1.0.0-rc.6",
+  "version": "1.0.0-rc.7",
   "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.4.3",
     "eventemitter3": "^5.0.1",
-    "graphile-config": "^1.0.0-rc.4",
+    "graphile-config": "^1.0.0-rc.5",
     "graphql": "^16.9.0",
     "iterall": "^1.3.0",
     "tslib": "^2.8.1"