grafast 0.1.1-beta.2 → 0.1.1-beta.21

package/dist/utils.js

@@ -1,12 +1,45 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasItemPlan = exports.assertNotAsync = exports.canonicalJSONStringify = exports.stepsAreInSamePhase = exports.stepAMayDependOnStepB = exports.stepADependsOnStepB = exports.isTypePlanned = exports.findVariableNamesUsed = exports.arrayOfLengthCb = exports.arrayOfLength = exports.stack = exports.sharedNull = exports.getEnumValueConfig = exports.inputObjectFieldSpec = exports.newInputObjectTypeBuilder = exports.newGrafastFieldConfigBuilder = exports.objectFieldSpec = exports.newObjectTypeBuilder = exports.objectSpec = exports.arraysMatch = exports.isDeferred = exports.isPromiseLike = exports.isPromise = exports.defaultValueToValueNode = exports.assertNullPrototype = exports.ROOT_VALUE_OBJECT = void 0;
+exports.canonicalJSONStringify = exports.valueNodeToStaticValue = exports.sharedNull = exports.ROOT_VALUE_OBJECT = void 0;
+exports.assertNullPrototype = assertNullPrototype;
+exports.defaultValueToValueNode = defaultValueToValueNode;
+exports.isPromise = isPromise;
+exports.isPromiseLike = isPromiseLike;
+exports.isDeferred = isDeferred;
+exports.arraysMatch = arraysMatch;
+exports.objectSpec = objectSpec;
+exports.newObjectTypeBuilder = newObjectTypeBuilder;
+exports.objectFieldSpec = objectFieldSpec;
+exports.newGrafastFieldConfigBuilder = newGrafastFieldConfigBuilder;
+exports.newInputObjectTypeBuilder = newInputObjectTypeBuilder;
+exports.inputObjectFieldSpec = inputObjectFieldSpec;
+exports.getEnumValueConfigs = getEnumValueConfigs;
+exports.getEnumValueConfig = getEnumValueConfig;
+exports.stack = stack;
+exports.arrayOfLength = arrayOfLength;
+exports.arrayOfLengthCb = arrayOfLengthCb;
+exports.findVariableNamesUsedInValueNode = findVariableNamesUsedInValueNode;
+exports.findVariableNamesUsed = findVariableNamesUsed;
+exports.isTypePlanned = isTypePlanned;
+exports.sudo = sudo;
+exports.writeableArray = writeableArray;
+exports.stepADependsOnStepB = stepADependsOnStepB;
+exports.stepAMayDependOnStepB = stepAMayDependOnStepB;
+exports.stepsAreInSamePhase = stepsAreInSamePhase;
+exports.assertNotAsync = assertNotAsync;
+exports.assertNotPromise = assertNotPromise;
+exports.hasItemPlan = hasItemPlan;
+exports.exportNameHint = exportNameHint;
+exports.isTuple = isTuple;
+exports.digestKeys = digestKeys;
+exports.directiveArgument = directiveArgument;
 const tslib_1 = require("tslib");
 const graphql = tslib_1.__importStar(require("graphql"));
 const assert = tslib_1.__importStar(require("./assert.js"));
 const dev_js_1 = require("./dev.js");
 const error_js_1 = require("./error.js");
 const inspect_js_1 = require("./inspect.js");
+const constant_js_1 = require("./steps/constant.js");
 const { GraphQLBoolean, GraphQLEnumType, GraphQLFloat, GraphQLID, GraphQLInputObjectType, GraphQLInt, GraphQLInterfaceType, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLScalarType, GraphQLString, GraphQLUnionType, Kind, } = graphql;
 /**
  * The parent object is used as the key in `GetValueStepId()`; for root level
@@ -20,7 +53,6 @@ function assertNullPrototype(object, description) {
         assert.strictEqual(Object.getPrototypeOf(object), null, `Expected ${description} to have a null prototype`);
     }
 }
-exports.assertNullPrototype = assertNullPrototype;
 /**
  * Converts a JSON value into the equivalent ValueNode _without_ checking that
  * it's compatible with the expected type. Typically only used with scalars
@@ -181,21 +213,18 @@ function defaultValueToValueNode(type, defaultValue) {
     }
     return rawValueToValueNode(type, defaultValue);
 }
-exports.defaultValueToValueNode = defaultValueToValueNode;
 function isPromise(t) {
     return (typeof t === "object" &&
         t !== null &&
         typeof t.then === "function" &&
         typeof t.catch === "function");
 }
-exports.isPromise = isPromise;
 /**
  * Is "thenable".
  */
 function isPromiseLike(t) {
     return t != null && typeof t.then === "function";
 }
-exports.isPromiseLike = isPromiseLike;
 /**
  * Is a promise that can be externally resolved.
  */
@@ -204,7 +233,6 @@ function isDeferred(t) {
         typeof t.resolve === "function" &&
         typeof t.reject === "function");
 }
-exports.isDeferred = isDeferred;
 /**
  * Returns true if array1 and array2 have the same length, and every pair of
  * values within them pass the `comparator` check (which defaults to `===`).
@@ -232,7 +260,6 @@ function arraysMatch(array1, array2, comparator) {
     }
     return true;
 }
-exports.arraysMatch = arraysMatch;
 /**
  * Saves us having to write `extensions: {grafast: {...}}` everywhere.
  */
@@ -262,14 +289,12 @@ function objectSpec(spec) {
     };
     return modifiedSpec;
 }
-exports.objectSpec = objectSpec;
 /**
  * @remarks This is a mess because the first two generics need to be specified manually, but the latter one we want inferred.
  */
 function newObjectTypeBuilder(assertStep) {
     return (spec) => new GraphQLObjectType(objectSpec({ assertStep, ...spec }));
 }
-exports.newObjectTypeBuilder = newObjectTypeBuilder;
 /**
  * Saves us having to write `extensions: {grafast: {...}}` everywhere.
  */
@@ -279,23 +304,26 @@ function objectFieldSpec(grafastSpec, path) {
     assertNotAsync(subscribePlan, `${path ?? "?"}.subscribePlan`);
     const argsWithExtensions = args
         ? Object.keys(args).reduce((memo, argName) => {
-            const { inputPlan, applyPlan, autoApplyAfterParentPlan, autoApplyAfterParentSubscribePlan, ...argSpec } = args[argName];
-            assertNotAsync(inputPlan, `${path ?? "?"}(${argName}:).inputPlan`);
+            const grafastArgSpec = args[argName];
+            // TODO: remove this code
+            if (grafastArgSpec.inputPlan ||
+                grafastArgSpec.autoApplyAfterParentPlan ||
+                grafastArgSpec.autoApplyAfterParentSubscribePlan) {
+                throw new Error(`Argument at ${path} has inputPlan or autoApplyAfterParentPlan or autoApplyAfterParentSubscribePlan set; these properties no longer do anything and should be removed.`);
+            }
+            const { applyPlan, applySubscribePlan, ...argSpec } = grafastArgSpec;
             assertNotAsync(applyPlan, `${path ?? "?"}(${argName}:).applyPlan`);
+            assertNotAsync(applySubscribePlan, `${path ?? "?"}(${argName}:).applySubscribePlan`);
             memo[argName] = {
                 ...argSpec,
-                ...(inputPlan || applyPlan
+                ...(applyPlan || applySubscribePlan
                     ? {
                         extensions: {
+                            ...argSpec.extensions,
                             grafast: {
-                                ...(inputPlan ? { inputPlan } : null),
-                                ...(autoApplyAfterParentPlan
-                                    ? { autoApplyAfterParentPlan }
-                                    : null),
+                                ...argSpec.extensions?.grafast,
                                 ...(applyPlan ? { applyPlan } : null),
-                                ...(autoApplyAfterParentSubscribePlan
-                                    ? { autoApplyAfterParentSubscribePlan }
-                                    : null),
+                                ...(applySubscribePlan ? { applySubscribePlan } : null),
                             },
                         },
                     }
@@ -321,7 +349,6 @@ function objectFieldSpec(grafastSpec, path) {
             : null),
     };
 }
-exports.objectFieldSpec = objectFieldSpec;
 /**
  * "Constrainted identity function" for field configs.
  *
@@ -330,7 +357,6 @@ exports.objectFieldSpec = objectFieldSpec;
 function newGrafastFieldConfigBuilder() {
     return (config) => config;
 }
-exports.newGrafastFieldConfigBuilder = newGrafastFieldConfigBuilder;
 function inputObjectSpec(spec) {
     const modifiedSpec = {
         ...spec,
@@ -348,52 +374,53 @@ function inputObjectSpec(spec) {
 function newInputObjectTypeBuilder() {
     return (spec) => new GraphQLInputObjectType(inputObjectSpec(spec));
 }
-exports.newInputObjectTypeBuilder = newInputObjectTypeBuilder;
 /**
  * Saves us having to write `extensions: {grafast: {...}}` everywhere.
  */
 function inputObjectFieldSpec(grafastSpec, path) {
-    const { inputPlan, applyPlan, autoApplyAfterParentInputPlan, autoApplyAfterParentApplyPlan, ...spec } = grafastSpec;
-    assertNotAsync(inputPlan, `${path ?? "?"}.inputPlan`);
-    assertNotAsync(applyPlan, `${path ?? "?"}.applyPlan`);
-    return inputPlan || applyPlan
+    // TODO: remove this code
+    if (grafastSpec.applyPlan ||
+        grafastSpec.inputPlan ||
+        grafastSpec.autoApplyAfterParentApplyPlan ||
+        grafastSpec.autoApplyAfterParentInputPlan) {
+        throw new Error(`Input field at ${path} has applyPlan or inputPlan or autoApplyAfterParentApplyPlan or autoApplyAfterParentInputPlan set; these properties no longer do anything and should be removed.`);
+    }
+    const { apply, ...spec } = grafastSpec;
+    assertNotAsync(apply, `${path ?? "?"}.apply`);
+    return apply
         ? {
             ...spec,
             extensions: {
+                ...spec.extensions,
                 grafast: {
-                    ...(inputPlan ? { inputPlan } : null),
-                    ...(applyPlan ? { applyPlan } : null),
-                    ...(autoApplyAfterParentInputPlan
-                        ? { autoApplyAfterParentInputPlan }
-                        : null),
-                    ...(autoApplyAfterParentApplyPlan
-                        ? { autoApplyAfterParentApplyPlan }
-                        : null),
+                    ...spec.extensions?.grafast,
+                    apply,
                 },
             },
         }
         : spec;
 }
-exports.inputObjectFieldSpec = inputObjectFieldSpec;
 const $$valueConfigByValue = Symbol("valueConfigByValue");
-/**
- * This would be equivalent to `enumType._valueLookup.get(outputValue)` except
- * that's not a public API so we have to do a bit of heavy lifting here. Since
- * it is heavy lifting, we cache the result, but we don't know when enumType
- * will go away so we use a weakmap.
- */
-function getEnumValueConfig(enumType, outputValue) {
+function getEnumValueConfigs(enumType) {
     // We cache onto the enumType directly so that garbage collection can clear up after us easily.
-    if (!enumType[$$valueConfigByValue]) {
+    if (enumType[$$valueConfigByValue] === undefined) {
         const config = enumType.toConfig();
         enumType[$$valueConfigByValue] = Object.values(config.values).reduce((memo, value) => {
             memo[value.value] = value;
             return memo;
         }, Object.create(null));
     }
-    return enumType[$$valueConfigByValue][outputValue];
+    return enumType[$$valueConfigByValue];
+}
+/**
+ * This would be equivalent to `enumType._valueLookup.get(outputValue)` except
+ * that's not a public API so we have to do a bit of heavy lifting here. Since
+ * it is heavy lifting, we cache the result, but we don't know when enumType
+ * will go away so we use a weakmap.
+ */
+function getEnumValueConfig(enumType, outputValue) {
+    return getEnumValueConfigs(enumType)[outputValue];
 }
-exports.getEnumValueConfig = getEnumValueConfig;
 /**
  * It's a peculiarity of V8 that `{}` is twice as fast as
  * `Object.create(null)`, but `Object.create(sharedNull)` is the same speed as
@@ -427,11 +454,8 @@ function stack(message, length = 4) {
         console.log(mapped.join("\n"));
     }
 }
-exports.stack = stack;
 /**
  * Ridiculously, this is faster than `new Array(length).fill(fill)`
- *
- * @internal
  */
 function arrayOfLength(length, fill) {
     const arr = [];
@@ -440,7 +464,6 @@ function arrayOfLength(length, fill) {
     }
     return arr;
 }
-exports.arrayOfLength = arrayOfLength;
 /**
  * Builds an array of length `length` calling `fill` for each entry in the
  * list and storing the result.
@@ -454,7 +477,7 @@ function arrayOfLengthCb(length, fill) {
     }
     return arr;
 }
-exports.arrayOfLengthCb = arrayOfLengthCb;
+exports.valueNodeToStaticValue = graphql.valueFromAST;
 function findVariableNamesUsedInValueNode(valueNode, variableNames) {
     switch (valueNode.kind) {
         case Kind.INT:
@@ -557,7 +580,6 @@ function findVariableNamesUsed(operationPlan, field) {
     findVariableNamesUsedInFieldNode(operationPlan, field, variableNames);
     return [...variableNames].sort();
 }
-exports.findVariableNamesUsed = findVariableNamesUsed;
 function isTypePlanned(schema, namedType) {
     if (namedType instanceof GraphQLObjectType) {
         return !!namedType.extensions?.grafast?.assertStep;
@@ -586,13 +608,37 @@ function isTypePlanned(schema, namedType) {
         return false;
     }
 }
-exports.isTypePlanned = isTypePlanned;
+/**
+ * Make protected/private methods accessible.
+ *
+ * @internal
+ */
+function sudo(obj) {
+    return obj;
+}
+/**
+ * We want everything else to treat things like `dependencies` as read only,
+ * however we ourselves want to be able to write to them, so we can use
+ * writeable for this.
+ *
+ * @internal
+ */
+function writeableArray(a) {
+    return a;
+}
+/**
+ * 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 stepA.dependencies) {
+    for (const dep of sudo(stepA).dependencies) {
         if (dep === stepB) {
             return true;
         }
@@ -602,15 +648,22 @@ function stepADependsOnStepB(stepA, stepB) {
     }
     return false;
 }
-exports.stepADependsOnStepB = stepADependsOnStepB;
 /**
  * Returns true if stepA is allowed to depend on stepB, false otherwise. (This
  * mostly relates to heirarchy.)
  */
 function stepAMayDependOnStepB($a, $b) {
-    return ($a.layerPlan.ancestry.includes($b.layerPlan) && !stepADependsOnStepB($b, $a));
+    if ($a.isFinalized) {
+        return false;
+    }
+    if ($a._isUnaryLocked && $a._isUnary && !$b._isUnary) {
+        return false;
+    }
+    if (!$a.layerPlan.ancestry.includes($b.layerPlan)) {
+        return false;
+    }
+    return !stepADependsOnStepB($b, $a);
 }
-exports.stepAMayDependOnStepB = stepAMayDependOnStepB;
 /**
  * For a regular GraphQL query with no `@stream`/`@defer`, the entire result is
  * calculated and then the output is generated and sent to the client at once.
@@ -681,18 +734,85 @@ function stepsAreInSamePhase(ancestor, descendent) {
     } while ((currentLayerPlan = currentLayerPlan.parentLayerPlan));
     throw new Error(`${descendent} is not dependent on ${ancestor}, perhaps you passed the arguments in the wrong order?`);
 }
-exports.stepsAreInSamePhase = stepsAreInSamePhase;
 // ENHANCE: implement this!
 const canonicalJSONStringify = (o) => JSON.stringify(o);
 exports.canonicalJSONStringify = canonicalJSONStringify;
+// PERF: only do this if isDev; otherwise replace with NOOP?
 function assertNotAsync(fn, name) {
     if (fn?.constructor?.name === "AsyncFunction") {
         throw new Error(`Plans must be synchronous, but this schema has an async function at '${name}': ${fn.toString()}`);
     }
 }
-exports.assertNotAsync = assertNotAsync;
+// PERF: only do this if isDev; otherwise replace with NOOP?
+function assertNotPromise(value, fn, name) {
+    if (isPromiseLike(value)) {
+        throw new Error(`Plans must be synchronous, but this schema has an function at '${name}' that returned a promise-like object: ${fn.toString()}`);
+    }
+    return value;
+}
 function hasItemPlan(step) {
     return "itemPlan" in step && typeof step.itemPlan === "function";
 }
-exports.hasItemPlan = hasItemPlan;
+function exportNameHint(obj, nameHint) {
+    if ((typeof obj === "object" && obj != null) || typeof obj === "function") {
+        if (!("$exporter$name" in obj)) {
+            Object.defineProperty(obj, "$exporter$name", {
+                writable: true,
+                value: nameHint,
+            });
+        }
+        else if (!obj.$exporter$name) {
+            obj.$exporter$name = nameHint;
+        }
+    }
+}
+function isTuple(t) {
+    return Array.isArray(t);
+}
+/**
+ * Turns an array of keys into a digest, avoiding conflicts.
+ * Symbols are treated as equivalent. (Theoretically faster
+ * than JSON.stringify().)
+ */
+function digestKeys(keys) {
+    let str = "";
+    for (let i = 0, l = keys.length; i < l; i++) {
+        const item = keys[i];
+        if (typeof item === "string") {
+            // str += `|§${item.replace(/§/g, "§§")}§`;
+            str += `§${item.length}:${item}`;
+        }
+        else if (typeof item === "number") {
+            str += `N${item}`;
+        }
+        else {
+            str += "!";
+        }
+    }
+    return str;
+}
+/**
+ * If the directive has the argument `argName`, return a step representing that
+ * arguments value, whether that be a step representing the relevant variable
+ * or a constant step representing the hardcoded value in the document.
+ *
+ * @remarks NOT SUITABLE FOR USAGE WITH LISTS OR OBJECTS! Does not evaluate
+ * internal variable usages e.g. `[1, $b, 3]`
+ */
+function directiveArgument(operationPlan, directive, argName, expectedKind) {
+    const arg = directive.arguments?.find((n) => n.name.value === argName);
+    if (!arg)
+        return undefined;
+    const val = arg.value;
+    return val.kind === graphql.Kind.VARIABLE
+        ? operationPlan.variableValuesStep.get(val.name.value)
+        : val.kind === expectedKind
+            ? (0, constant_js_1.constant)(val.kind === Kind.INT
+                ? parseInt(val.value, 10)
+                : val.kind === Kind.FLOAT
+                    ? parseFloat(val.value)
+                    : // boolean, string
+                        val.value)
+            : undefined;
+}
 //# sourceMappingURL=utils.js.map

package/dist/version.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grafast",
-  "version": "0.1.1-beta.2",
+  "version": "0.1.1-beta.21",
   "description": "Cutting edge GraphQL planning and execution engine",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -59,23 +59,20 @@
     "chalk": "^4.1.2",
     "debug": "^4.3.4",
     "eventemitter3": "^5.0.1",
+    "graphile-config": "^0.0.1-beta.15",
     "graphql": "^16.1.0-experimental-stream-defer.6",
     "iterall": "^1.3.0",
-    "tamedevil": "^0.0.0-beta.3",
+    "tamedevil": "^0.0.0-beta.7",
     "tslib": "^2.6.2"
   },
   "peerDependencies": {
-    "@envelop/core": "^3.0.4",
-    "graphile-config": "^0.0.1-beta.5",
+    "@envelop/core": "^5.0.0",
     "graphql": "^16.1.0-experimental-stream-defer.6",
-    "tamedevil": "^0.0.0-beta.3"
+    "tamedevil": "^0.0.0-beta.7"
   },
   "peerDependenciesMeta": {
     "@envelop/core": {
       "optional": true
-    },
-    "graphile-config": {
-      "optional": true
     }
   },
   "files": [