grafast 0.1.1-beta.11 → 0.1.1-beta.13

package/dist/steps/__inputObject.js

@@ -2,11 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.__InputObjectStep = void 0;
 const tslib_1 = require("tslib");
+const graphql = tslib_1.__importStar(require("graphql"));
 const tamedevil_1 = tslib_1.__importDefault(require("tamedevil"));
 const input_js_1 = require("../input.js");
 const step_js_1 = require("../step.js");
 const utils_js_1 = require("../utils.js");
 const constant_js_1 = require("./constant.js");
+const { Kind } = graphql;
 /**
  * Implements `InputObjectStep`
  */
@@ -123,6 +125,40 @@ class __InputObjectStep extends step_js_1.UnbatchedExecutableStep {
         }
         return !this.inputFields[attrName].step.evalIs(undefined);
     }
+    evalKeys() {
+        if (this.inputValues === undefined) {
+            return null;
+        }
+        else if (this.inputValues.kind === Kind.NULL) {
+            return null;
+        }
+        else if (this.inputValues.kind !== Kind.OBJECT) {
+            throw new Error("evalKeys must only be called for object types");
+        }
+        const keys = [];
+        const inputFieldKeys = Object.keys(this.inputFields);
+        for (let i = 0; i < inputFieldKeys.length; i++) {
+            const key = inputFieldKeys[i];
+            const inputFieldPlan = this.inputFields[key].step;
+            // This evalIs() is required. With __inputObject we know that it's an
+            // explicit input object (not variable) in the GraphQL document, but the
+            // values of each key may still be undefined if they're a variable that
+            // isn't supplied and has no default. In these cases we do not wish to
+            // return these keys (since the input object is not seen as having those
+            // keys set), but that will differ on an operation-to-operation basis,
+            // and thus we must evaluate whether or not they are undefined. Note that
+            // this implicitly adds constraints for these values; we do not need to
+            // explicitly add any constraint for the object itself because the
+            // document itself guarantees it will always be present.
+            //
+            // PERF: We should not need to .evalIs(undefined) for any input field
+            // that is declared as non-nullable, I think?
+            if (!inputFieldPlan.evalIs(undefined)) {
+                keys.push(key);
+            }
+        }
+        return keys;
+    }
 }
 exports.__InputObjectStep = __InputObjectStep;
 //# sourceMappingURL=__inputObject.js.map

package/dist/steps/__item.d.ts

@@ -1,4 +1,4 @@
-import type { JSONValue } from "../index.js";
+import type { GrafastResultsList, JSONValue } from "../index.js";
 import { $$deepDepSkip } from "../interfaces.js";
 import type { ExecutableStep } from "../step.js";
 import { $$noExec, UnbatchedExecutableStep } from "../step.js";
@@ -20,8 +20,8 @@ export declare class __ItemStep<TData> extends UnbatchedExecutableStep<TData> {
     planJSONExtra(): Record<string, JSONValue | undefined> | undefined;
     getParentStep(): ExecutableStep;
     [$$deepDepSkip](): ExecutableStep;
-    execute(): never;
-    unbatchedExecute(): never;
+    execute(): GrafastResultsList<TData>;
+    unbatchedExecute(): TData;
     finalize(): void;
 }
 //# sourceMappingURL=__item.d.ts.map

package/dist/steps/__trackedValue.d.ts

@@ -83,6 +83,14 @@ export declare class __TrackedValueStep<TData = any, TInputType extends GraphQLI
      * **WARNING**: avoid using this where possible, it causes OpPlans to split.
      */
     evalHas(key: string): boolean;
+    /**
+     * Evaluates the keys of the current value, and adds a
+     * constraint to the OpPlan to ensure that all future evaluations of this
+     * check will always return the same result.
+     *
+     * **WARNING**: avoid using this where possible, it causes OpPlans to split.
+     */
+    evalKeys(): ReadonlyArray<keyof TData & string> | null;
     /**
      * Evaluates the length of the current value (assumed to be an array), and
      * adds a constraint to the OpPlan to ensure that all future values will have

package/dist/steps/__trackedValue.js

@@ -231,6 +231,46 @@ class __TrackedValueStep extends step_js_1.UnbatchedExecutableStep {
         });
         return exists;
     }
+    /**
+     * Evaluates the keys of the current value, and adds a
+     * constraint to the OpPlan to ensure that all future evaluations of this
+     * check will always return the same result.
+     *
+     * **WARNING**: avoid using this where possible, it causes OpPlans to split.
+     */
+    evalKeys() {
+        const { value, path } = this;
+        if (!(0, graphql_1.isInputObjectType)(this.nullableGraphQLType)) {
+            throw new Error("evalKeys must only be called for object types");
+        }
+        if (value == null) {
+            this.constraints.push({
+                type: "keys",
+                path,
+                keys: null,
+            });
+            return null;
+        }
+        const keys = [];
+        const keysOfType = Object.keys(this.nullableGraphQLType.getFields());
+        // NOTE: it's important that we loop through the fields in their defined
+        // order, this ensures the `keys` array always has consistent ordering.
+        for (let i = 0; i < keysOfType.length; i++) {
+            const key = keysOfType[i];
+            // NOTE: `key in value` would be more performant here, but we cannot trust
+            // users not to pass `{foo: undefined}` so we must do the more expensive
+            // `value[key] !== undefined` check.
+            if (value[key] !== undefined) {
+                keys.push(key);
+            }
+        }
+        this.constraints.push({
+            type: "keys",
+            path,
+            keys,
+        });
+        return keys;
+    }
     /**
      * Evaluates the length of the current value (assumed to be an array), and
      * adds a constraint to the OpPlan to ensure that all future values will have

package/dist/steps/__value.d.ts

@@ -1,3 +1,4 @@
+import type { GrafastResultsList } from "../index.js";
 import { $$noExec, ExecutableStep } from "../step.js";
 import type { AccessStep } from "./access.js";
 /**
@@ -14,7 +15,7 @@ export declare class __ValueStep<TData> extends ExecutableStep<TData> {
     [$$noExec]: boolean;
     constructor();
     toStringMeta(): string | null;
-    execute(): never;
+    execute(): GrafastResultsList<TData>;
     get<TAttr extends keyof TData>(attrName: TAttr): AccessStep<TData[TAttr]>;
     at<TIndex extends keyof TData>(index: TIndex): AccessStep<TData[TIndex]>;
 }

package/dist/steps/constant.d.ts

@@ -18,6 +18,8 @@ export declare class ConstantStep<TData> extends UnbatchedExecutableStep<TData>
     eval(): TData;
     evalIs(value: any): boolean;
     evalIsEmpty(): boolean;
+    evalLength(): number | null;
+    evalKeys(): ReadonlyArray<keyof TData & string> | null;
     unbatchedExecute(): TData;
     isNull(): boolean;
     isUndefined(): boolean;

package/dist/steps/constant.js

@@ -43,6 +43,18 @@ class ConstantStep extends step_js_1.UnbatchedExecutableStep {
             this.data !== null &&
             Object.keys(this.data).length === 0);
     }
+    evalLength() {
+        return Array.isArray(this.data) ? this.data.length : null;
+    }
+    evalKeys() {
+        if (this.data == null || typeof this.data !== "object") {
+            return null;
+        }
+        else {
+            const data = this.data;
+            return Object.keys(data).filter((k) => data[k] !== undefined);
+        }
+    }
     unbatchedExecute() {
         return this.data;
     }

package/dist/steps/graphqlResolver.js

@@ -8,7 +8,7 @@ const index_js_1 = require("../index.js");
 const polymorphic_js_1 = require("../polymorphic.js");
 const step_js_1 = require("../step.js");
 const utils_js_1 = require("../utils.js");
-const { defaultTypeResolver, getNamedType, getNullableType, isAbstractType, isListType, } = graphql;
+const { defaultTypeResolver, getNamedType, getNullableType, isAbstractType, isListType, isNonNullType, } = graphql;
 function dcr(data, // but not a promise
 context, resolveInfo) {
     if (data == null) {
@@ -69,9 +69,6 @@ class GraphQLResolverStep extends step_js_1.UnbatchedExecutableStep {
             this.subscriber?.name ||
             null);
     }
-    deduplicate(peers) {
-        return peers.filter((peer) => peer.resolver === this.resolver && peer.subscriber === this.subscriber);
-    }
     unbatchedExecute(_extra, source, args, context, variableValues, rootValue) {
         if (this.isNotRoot && source == null) {
             return source;
@@ -142,7 +139,13 @@ class GraphQLItemHandler extends step_js_1.ExecutableStep {
         this.isSyncAndSafe = false;
         this.addDependency($parent);
         if (isListType(nullableType)) {
-            this.nullableInnerType = nullableType.ofType;
+            const innerType = nullableType.ofType;
+            if (isNonNullType(innerType)) {
+                this.nullableInnerType = innerType.ofType;
+            }
+            else {
+                this.nullableInnerType = innerType;
+            }
         }
         else {
             if (!isAbstractType(nullableType)) {

package/dist/steps/listen.d.ts

@@ -1,4 +1,4 @@
-import type { GrafastResultStreamList, GrafastSubscriber, StreamDetails } from "../interfaces.js";
+import type { GrafastResultsList, GrafastResultStreamList, GrafastSubscriber, StreamDetails } from "../interfaces.js";
 import type { StreamableStep } from "../step.js";
 import { ExecutableStep } from "../step.js";
 import type { __ItemStep } from "./__item.js";
@@ -25,7 +25,7 @@ export declare class ListenStep<TTopics extends {
      */
     private topicDep;
     constructor(pubsubOrPlan: ExecutableStep<GrafastSubscriber<TTopics> | null> | GrafastSubscriber<TTopics> | null, topicOrPlan: ExecutableStep<TTopic> | string, itemPlan?: (itemPlan: __ItemStep<TTopics[TTopic]>) => TPayloadStep);
-    execute(): never;
+    execute(): GrafastResultsList<TTopics[TTopic]>;
     stream({ indexMap, values, }: StreamDetails<readonly [GrafastSubscriber<TTopics>, TTopic]>): GrafastResultStreamList<TTopics[TTopic]>;
 }
 /**

package/dist/steps/object.d.ts

@@ -49,7 +49,7 @@ export declare class ObjectStep<TPlans extends {
     execute({ indexMap, values, extra, }: ExecutionDetails<Array<DataFromObjectSteps<TPlans>[keyof TPlans]>>): ReadonlyArray<DataFromObjectSteps<TPlans>>;
     unbatchedExecute(_extra: UnbatchedExecutionExtra, ..._values: any[]): any;
     deduplicate(peers: ObjectStep<any>[]): ObjectStep<TPlans>[];
-    optimize(opts: StepOptimizeOptions): ConstantStep<any> | this;
+    optimize(opts: StepOptimizeOptions): ConstantStep<any> | this | ConstantStep<Record<string, any>>;
     /**
      * Get the original plan with the given key back again.
      */

package/dist/steps/sideEffect.d.ts

@@ -12,7 +12,6 @@ export declare class SideEffectStep<TIn, TOut> extends UnbatchedExecutableStep<T
     };
     isSyncAndSafe: boolean;
     allowMultipleOptimizations: boolean;
-    hasSideEffects: boolean;
     private planDep;
     constructor($plan: ExecutableStep<TIn> | null | undefined, fn: (value: TIn) => PromiseOrDirect<TOut>);
     toStringMeta(): any;

package/dist/thereCanBeOnlyOne.js

@@ -6,7 +6,7 @@ if (globalAny[$$grafast] === true) {
     // Already warned
 }
 else if (globalAny[$$grafast]) {
-    console.trace(`WARNING: more than one version of the 'grafast' module has been instantiated - you must ensure there is exactly one grafast (e.g. using yarn "resolutions" or similar techniques). Try clearing your package lockfile and reinstalling. ${globalAny[$$grafast].stack}`);
+    console.trace(`WARNING: more than one version of the 'grafast' module has been instantiated - you must ensure there is exactly one grafast (e.g. using yarn "resolutions" or similar techniques). Try clearing your package lockfile and reinstalling.\n    ${String(globalAny[$$grafast].stack).replace(/\n/g, "\n    ")}`);
     globalAny[$$grafast] = true;
 }
 else {

package/dist/utils.d.ts

@@ -103,6 +103,10 @@ export declare function arrayOfLength(length: number, fill?: any): any[];
  */
 export declare function findVariableNamesUsed(operationPlan: OperationPlan, field: FieldNode): string[];
 export declare function isTypePlanned(schema: GraphQLSchema, namedType: GraphQLNamedType): boolean;
+/**
+ * Returns `true` if the first argument depends on the second argument either
+ * directly or indirectly (via a chain of dependencies).
+ */
 export declare function stepADependsOnStepB(stepA: ExecutableStep, stepB: ExecutableStep): boolean;
 /**
  * Returns true if stepA is allowed to depend on stepB, false otherwise. (This

package/dist/utils.js

@@ -605,10 +605,17 @@ function writeableArray(a) {
     return a;
 }
 exports.writeableArray = writeableArray;
+/**
+ * Returns `true` if the first argument depends on the second argument either
+ * directly or indirectly (via a chain of dependencies).
+ */
 function stepADependsOnStepB(stepA, stepB) {
     if (stepA === stepB) {
         throw new Error("Invalid call to stepADependsOnStepB");
     }
+    // PERF: bredth-first might be better.
+    // PERF: we can stop looking once we pass a certain layerPlan boundary.
+    // PERF: maybe some form of caching here would be sensible?
     // Depth-first search for match
     for (const dep of sudo(stepA).dependencies) {
         if (dep === stepB) {

package/dist/version.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grafast",
-  "version": "0.1.1-beta.11",
+  "version": "0.1.1-beta.13",
   "description": "Cutting edge GraphQL planning and execution engine",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",