grafast 0.1.1-beta.11 → 0.1.1-beta.12

package/README.md

@@ -51,11 +51,8 @@ And please give some love to our featured sponsors 🤩:
 <table><tr>
 <td align="center"><a href="https://www.the-guild.dev/"><img src="https://graphile.org/images/sponsors/theguild.png" width="90" height="90" alt="The Guild" /><br />The Guild</a> *</td>
 <td align="center"><a href="https://dovetailapp.com/"><img src="https://graphile.org/images/sponsors/dovetail.png" width="90" height="90" alt="Dovetail" /><br />Dovetail</a> *</td>
-<td align="center"><a href="https://www.netflix.com/"><img src="https://graphile.org/images/sponsors/Netflix.png" width="90" height="90" alt="Netflix" /><br />Netflix</a> *</td>
 <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/args.js

@@ -5,6 +5,7 @@ const interfaces_js_1 = require("./interfaces.js");
 const middleware_js_1 = require("./middleware.js");
 const utils_js_1 = require("./utils.js");
 const EMPTY_OBJECT = Object.freeze(Object.create(null));
+const $$writeTest = Symbol("grafastWriteTest");
 /**
  * Applies Graphile Config hooks to your GraphQL request, e.g. to
  * populate context or similar.
@@ -19,8 +20,13 @@ function hookArgs(rawArgs, legacyResolvedPreset, legacyCtx) {
         rawArgs.requestContext = rawArgs.requestContext ?? legacyCtx;
     }
     const { middleware: rawMiddleware, resolvedPreset, contextValue: rawContextValue, } = rawArgs;
-    // Make context mutable
-    rawArgs.contextValue = Object.assign(Object.create(null), rawContextValue);
+    try {
+        rawContextValue[$$writeTest] = true;
+    }
+    catch (e) {
+        // Make context mutable
+        rawArgs.contextValue = Object.assign(Object.create(null), rawContextValue);
+    }
     const middleware = rawMiddleware === undefined && resolvedPreset != null
         ? (0, middleware_js_1.getGrafastMiddleware)(resolvedPreset)
         : rawMiddleware ?? null;

package/dist/constraints.d.ts

@@ -27,6 +27,20 @@ interface ExistsConstraint {
     path: (string | number)[];
     exists: boolean;
 }
+/**
+ * If `keys` is null: asserts that there is no value at the given
+ * path.
+ *
+ * Otherwise: asserts that the value at the given path has the exact same keys.
+ */
+interface KeysConstraint {
+    type: "keys";
+    path: (string | number)[];
+    /**
+     * If this is null it implies that the object did not exist.
+     */
+    keys: ReadonlyArray<string> | null;
+}
 /**
  * If `expectedLength` is null: asserts that there is no value at the given
  * path.
@@ -52,7 +66,7 @@ interface IsEmptyConstraint {
     path: (string | number)[];
     isEmpty: boolean;
 }
-export type Constraint = ValueConstraint | EqualityConstraint | ExistsConstraint | LengthConstraint | IsEmptyConstraint;
+export type Constraint = ValueConstraint | EqualityConstraint | ExistsConstraint | LengthConstraint | IsEmptyConstraint | KeysConstraint;
 /**
  * Implements the `MatchesConstraints` algorithm.
  */

package/dist/constraints.js

@@ -32,7 +32,8 @@ function matchesConstraint(constraint, object) {
     const value = valueAtPath(object, constraint.path);
     switch (constraint.type) {
         case "length": {
-            return Array.isArray(value) && value.length === constraint.expectedLength;
+            const actualLength = Array.isArray(value) ? value.length : null;
+            return actualLength === constraint.expectedLength;
         }
         case "exists": {
             return (value !== undefined) === constraint.exists;
@@ -49,6 +50,44 @@ function matchesConstraint(constraint, object) {
                 Object.keys(value).length === 0;
             return isEmpty === constraint.isEmpty;
         }
+        case "keys": {
+            const { keys: expectedKeys } = constraint;
+            if (expectedKeys === null) {
+                return value == null || typeof value !== "object";
+            }
+            else if (value == null || typeof value !== "object") {
+                return false;
+            }
+            else {
+                // keys are always in order of the gql type; see coerceInputValue and __InputObjectStep ctor
+                const valueKeys = Object.keys(value);
+                const valueKeyCount = valueKeys.length;
+                const expectedKeyCount = expectedKeys.length;
+                // Optimization: early bail
+                if (valueKeyCount < expectedKeyCount) {
+                    return false;
+                }
+                /**
+                 * This is `i` but adjusted so that `undefined` doesn't increment it.
+                 * Should match index in `expectedKeys`.
+                 */
+                let definedRawKeyCount = 0;
+                for (let i = 0; i < valueKeyCount; i++) {
+                    const valueKey = valueKeys[i];
+                    if (value[valueKey] !== undefined) {
+                        if (valueKey !== expectedKeys[definedRawKeyCount]) {
+                            return false;
+                        }
+                        definedRawKeyCount++;
+                    }
+                }
+                // Make sure there aren't any additional expected keys
+                if (definedRawKeyCount !== expectedKeyCount) {
+                    return false;
+                }
+                return true;
+            }
+        }
         default: {
             const never = constraint;
             throw new Error(`Unsupported constraint type '${never.type}'`);

package/dist/engine/LayerPlan.d.ts

@@ -113,6 +113,7 @@ export declare class LayerPlan<TReason extends LayerPlanReason = LayerPlanReason
     constructor(operationPlan: OperationPlan, parentLayerPlan: LayerPlan | null, reason: TReason);
     toString(): string;
     print(depth?: number): string;
+    _hasSetRootStep: boolean;
     setRootStep($root: ExecutableStep): void;
     finalize(): void;
     newBucket(parentBucket: Bucket): Bucket | null;

package/dist/engine/LayerPlan.js

@@ -89,6 +89,23 @@ class LayerPlan {
         this.steps = [];
         /** @internal */
         this.pendingSteps = [];
+        /**
+         * This goes along with `parentStep` in the reason, except it applies to all
+         * layer plan types and we figure it out automatically from the parent layer
+         * plan. If this step has an error at a given index, then it should be
+         * treated as if the parentStep had an error at that same index.
+         *
+         * @internal
+         */
+        this.parentSideEffectStep = null;
+        /**
+         * This tracks the latest seen side effect at the current point in planning
+         * (such that created steps take this to be their implicitSideEffectStep).
+         * This isn't used once planning is complete.
+         *
+         * @internal
+         */
+        this.latestSideEffectStep = null;
         /**
          * Describes the order in which the steps within this LayerPlan are executed.
          *
@@ -97,6 +114,13 @@ class LayerPlan {
          * @internal
          */
         this.phases = [];
+        this._hasSetRootStep = false;
+        // This layer plan is dependent on the latest side effect. Note that when
+        // we set a `rootStep` later, if the root step is dependent on this step
+        // (directly or indirectly) we will clear this property.
+        this.parentSideEffectStep = parentLayerPlan?.latestSideEffectStep ?? null;
+        // There has yet to be any side effects created in this layer.
+        this.latestSideEffectStep = null;
         this.stepsByConstructor = new Map();
         if (parentLayerPlan !== null) {
             this.depth = parentLayerPlan.depth + 1;
@@ -133,7 +157,7 @@ class LayerPlan {
             ? `{${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}>`;
+        return `LayerPlan<${this.id}${chain}${this.parentSideEffectStep ? `^${this.parentSideEffectStep.id}` : ""}?${this.reason.type}${reasonExtra}!${this.rootStep?.id ?? "x"}${deps}>`;
     }
     print(depth = 0) {
         const output = [`${" ".repeat(depth * 2)}${this}`];
@@ -143,7 +167,15 @@ class LayerPlan {
         return output.join("\n");
     }
     setRootStep($root) {
+        if (this._hasSetRootStep) {
+            throw new Error(`Set root step on ${this} more than once`);
+        }
+        this._hasSetRootStep = true;
         this.operationPlan.stepTracker.setLayerPlanRootStep(this, $root);
+        // NOTE: we may clear `this.parentSideEffectStep` based on the `$root` step
+        // having an explicit dependency on `this.parentSideEffectStep`; but that
+        // will be done as part of `OperationPlan::finalizeLayerPlans()` because
+        // steps aren't assigned `implicitSideEffectStep`s until that point.
     }
     /** @internal Use plan.getStep(id) instead. */
     getStep(id, requestingStep) {
@@ -176,6 +208,14 @@ class LayerPlan {
             : [];
         const iterators = this.reason.type === "mutationField" ? parentBucket.iterators : [];
         const map = new Map();
+        const $parentSideEffect = this.parentSideEffectStep;
+        let parentSideEffectValue;
+        if ($parentSideEffect) {
+            parentSideEffectValue = parentBucket.store.get($parentSideEffect.id);
+        }
+        else {
+            parentSideEffectValue = null;
+        }
         let size = 0;
         switch (this.reason.type) {
             case "nullableBoundary": {
@@ -194,15 +234,20 @@ class LayerPlan {
                         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];
+                        const parentBucketSize = parentBucket.size;
+                        for (let originalIndex = 0; originalIndex < parentBucketSize; originalIndex++) {
+                            if (parentSideEffectValue === null ||
+                                !(parentSideEffectValue._flagsAt(originalIndex) & interfaces_js_1.FLAG_ERROR)) {
+                                const newIndex = size++;
+                                map.set(originalIndex, newIndex);
+                                polymorphicPathList[newIndex] =
+                                    parentBucket.polymorphicPathList[originalIndex];
+                                iterators[newIndex] = parentBucket.iterators[originalIndex];
+                            }
                         }
                     }
                 }
@@ -244,10 +289,12 @@ class LayerPlan {
                     // 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.at(originalIndex);
-                        if (fieldValue != null) {
+                        if ((parentSideEffectValue === null ||
+                            !(parentSideEffectValue._flagsAt(originalIndex) & interfaces_js_1.FLAG_ERROR)) &&
+                            !(nullableStepStore._flagsAt(originalIndex) & interfaces_js_1.FLAG_NULL)) {
                             const newIndex = size++;
                             map.set(originalIndex, newIndex);
+                            const fieldValue = nullableStepStore.at(originalIndex);
                             itemStepIdList[newIndex] = fieldValue;
                             polymorphicPathList[newIndex] =
                                 parentBucket.polymorphicPathList[originalIndex];
@@ -295,7 +342,9 @@ class LayerPlan {
                 // have parent buckets, so we must "multiply up" the store entries.
                 for (let originalIndex = 0; originalIndex < parentBucket.size; originalIndex++) {
                     const list = listStepStore.at(originalIndex);
-                    if (Array.isArray(list)) {
+                    if ((parentSideEffectValue === null ||
+                        !(parentSideEffectValue._flagsAt(originalIndex) & interfaces_js_1.FLAG_ERROR)) &&
+                        Array.isArray(list)) {
                         const newIndexes = [];
                         map.set(originalIndex, newIndexes);
                         for (let j = 0, l = list.length; j < l; j++) {
@@ -356,6 +405,10 @@ class LayerPlan {
                     if (flags & (interfaces_js_1.FLAG_ERROR | interfaces_js_1.FLAG_INHIBITED | interfaces_js_1.FLAG_NULL)) {
                         continue;
                     }
+                    if (parentSideEffectValue !== null &&
+                        parentSideEffectValue._flagsAt(originalIndex) & interfaces_js_1.FLAG_ERROR) {
+                        continue;
+                    }
                     const value = polymorphicPlanStore.at(originalIndex);
                     const typeName = (0, polymorphic_js_1.resolveType)(value);
                     if (!targetTypeNames.includes(typeName)) {