grafast 0.1.1-beta.0 → 0.1.1-beta.10

package/README.md

@@ -52,11 +52,10 @@ And please give some love to our featured sponsors 🤩:
 <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=""><img src="https://graphile.org/images/sponsors/chadf.png" width="90" height="90" alt="Chad Furman" /><br />Chad Furman</a> *</td>
-</tr><tr>
 <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>
-<td align="center"><a href="https://www.accenture.com/"><img src="https://graphile.org/images/sponsors/accenture.svg" width="90" height="90" alt="Accenture" /><br />Accenture</a> *</td>
-<td align="center"><a href="https://microteam.io/"><img src="https://graphile.org/images/sponsors/micro.png" width="90" height="90" alt="We Love Micro" /><br />We Love Micro</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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hookArgs = void 0;
+const config_js_1 = require("./config.js");
+const interfaces_js_1 = require("./interfaces.js");
+const utils_js_1 = require("./utils.js");
+/**
+ * Applies Graphile Config hooks to your GraphQL request, e.g. to
+ * populate context or similar.
+ *
+ * @experimental
+ */
+function hookArgs(rawArgs, resolvedPreset, ctx) {
+    const args = rawArgs;
+    // Assert that args haven't already been hooked
+    if (args[interfaces_js_1.$$hooked]) {
+        throw new Error("Must not call hookArgs twice!");
+    }
+    args[interfaces_js_1.$$hooked] = true;
+    // Make context mutable
+    args.contextValue = Object.assign(Object.create(null), args.contextValue);
+    // finalize(args): args is deliberately shadowed
+    const finalize = (args) => {
+        const userContext = resolvedPreset.grafast?.context;
+        if (typeof userContext === "function") {
+            const result = userContext(ctx, args);
+            if ((0, utils_js_1.isPromiseLike)(result)) {
+                // Deliberately shadowed 'result'
+                return result.then((result) => {
+                    Object.assign(args.contextValue, result);
+                    return args;
+                });
+            }
+            else {
+                Object.assign(args.contextValue, result);
+                return args;
+            }
+        }
+        else if (typeof userContext === "object" && userContext !== null) {
+            Object.assign(args.contextValue, userContext);
+            return args;
+        }
+        else {
+            return args;
+        }
+    };
+    if (resolvedPreset !== config_js_1.NULL_PRESET &&
+        resolvedPreset.plugins &&
+        resolvedPreset.plugins.length > 0) {
+        const event = { args, ctx, resolvedPreset };
+        const result = (0, config_js_1.hook)(resolvedPreset, "args", event);
+        if ((0, utils_js_1.isPromiseLike)(result)) {
+            return result.then(() => finalize(event.args));
+        }
+        else {
+            return finalize(event.args);
+        }
+    }
+    return finalize(args);
+}
+exports.hookArgs = hookArgs;
+//# sourceMappingURL=args.js.map

package/dist/assert.js

@@ -0,0 +1,24 @@
+"use strict";
+/*
+ * Due to the following Jest issue, GraphQL's `instanceof Error` test
+ * cannot pass for Node assertions. So we have to define our own.
+ *
+ * https://github.com/facebook/jest/issues/2549
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.strictEqual = exports.ok = void 0;
+/** Equivalent to `assert.ok(...)` */
+function ok(val, message) {
+    if (!val) {
+        throw new Error(message);
+    }
+}
+exports.ok = ok;
+/** Equivalent to `assert.strictEqual(...)` */
+function strictEqual(actual, expected, message) {
+    if (actual !== expected) {
+        throw new Error(message + ` (${actual} !== ${expected})`);
+    }
+}
+exports.strictEqual = strictEqual;
+//# sourceMappingURL=assert.js.map

package/dist/bucket.d.ts

@@ -1,90 +1,2 @@
-import type { LayerPlan } from "./engine/LayerPlan";
-import type { MetaByMetaKey } from "./engine/OperationPlan";
-import type { ExecutionEventEmitter } from "./interfaces.js";
-/**
- * @internal
- */
-export interface RequestTools {
-    /** The `timeSource.now()` at which the request started executing */
-    startTime: number;
-    /** The `timeSource.now()` at which the request should stop executing (if a timeout was configured) */
-    stopTime: number | null;
-    readonly eventEmitter: ExecutionEventEmitter | undefined;
-    /**
-     * If we're running inside GraphQL then we should not serialize scalars,
-     * otherwise we'll face the double-serialization problem.
-     */
-    insideGraphQL: false;
-}
-/**
- * A "bucket" is where the results from plans are stored so that other plans
- * can retrieve them, it may take on different forms depending on the mode of
- * execution. A "LayerPlan" is used to both identify the bucket and to specify
- * why it exists and how it behaves.
- *
- * Every `ExecutableStep` belongs to exactly one LayerPlan (and thus bucket),
- * specified by `plan.layerPlan`.
- *
- * @internal
- */
-export interface Bucket {
-    /**
-     * The LayerPlan definition this bucket adheres to
-     */
-    layerPlan: LayerPlan;
-    /**
-     * How many entries are there in the bucket?
-     */
-    size: number;
-    /**
-     * The polymorphic path through which each of the entries (respectively) has
-     * travelled. This influences the steps that will be executed using the
-     * related inputs.
-     */
-    polymorphicPathList: readonly (string | null)[];
-    /**
-     * These are the iterators the bucket (or its descendents, without crossing a
-     * stream/defer boundary) have created (if any). Each of these must either be
-     * processed via `processRoot`, or must be manually released (via
-     * `releaseUnusedIterators`) otherwise a memory leak could occur.
-     */
-    iterators: Array<Set<AsyncIterator<any> | Iterator<any>>>;
-    /**
-     * `metaByMetaKey` belongs to the bucket rather than the request context
-     * because mutations and subscriptions shouldn't re-use caches.
-     *
-     * TODO: `inheritMeta: boolean`?
-     */
-    metaByMetaKey: MetaByMetaKey;
-    /**
-     * Every entry in the store is a list with the same length as the bucket has
-     * `size`.
-     *
-     * The entry for '-1' is the request indexes, so we can associate the results
-     * back to the request that triggered them.
-     */
-    store: Map<number, any[]>;
-    /**
-     * Set this true when the bucket is fully executed.
-     *
-     * Initialize it to false.
-     */
-    isComplete: boolean;
-    /**
-     * If an error occurred at any stage we need to drop down to more careful
-     * (and slower) handling.
-     *
-     * Initialize it to false.
-     */
-    hasErrors: boolean;
-    /**
-     * The child buckets of this bucket.
-     */
-    children: {
-        [layerPlanId: number]: {
-            bucket: Bucket;
-            map: Map<number, number | number[]>;
-        };
-    };
-}
+export {};
 //# sourceMappingURL=bucket.d.ts.map

package/dist/bucket.js

@@ -0,0 +1,4 @@
+"use strict";
+// import type { GraphQLScalarType } from "graphql";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=bucket.js.map

package/dist/config.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hook = exports.withHooks = exports.withGraphileConfig = exports.NULL_PRESET = void 0;
+exports.NULL_PRESET = Object.freeze(Object.create(null));
+let graphileConfig = undefined;
+let graphileConfigLoaded = false;
+function withGraphileConfig(callback) {
+    if (graphileConfig === undefined) {
+        // ESM:
+        // This should be
+        //     graphileConfig = import("graphile-config").then(
+        // but that causes a segfault in jest/node when testing third party
+        // modules. So we had to convert everything to CommonJS.
+        graphileConfig = new Promise((resolve, reject) => {
+            try {
+                resolve(require("graphile-config"));
+            }
+            catch (e) {
+                if (e.code === "ERR_REQUIRE_ESM") {
+                    return import("graphile-config").then(resolve, reject);
+                }
+                else {
+                    reject(e);
+                }
+            }
+        }).then((GC) => {
+            graphileConfig = GC;
+            graphileConfigLoaded = true;
+            return GC;
+        }, () => {
+            graphileConfig = null;
+            graphileConfigLoaded = true;
+            return null;
+        });
+    }
+    if (graphileConfigLoaded) {
+        return callback(graphileConfig);
+    }
+    else {
+        return graphileConfig.then(callback);
+    }
+}
+exports.withGraphileConfig = withGraphileConfig;
+const $$skipHooks = Symbol("skipHooks");
+const $$hooksForPreset = Symbol("grafastHooks");
+function withHooks(resolvedPreset, callback) {
+    const existing = resolvedPreset[$$hooksForPreset];
+    if (existing !== undefined) {
+        return callback(existing);
+    }
+    if (!resolvedPreset.plugins || resolvedPreset.plugins.length === 0) {
+        resolvedPreset[$$hooksForPreset] = null;
+        return callback(null);
+    }
+    const plugins = resolvedPreset.plugins;
+    return withGraphileConfig((gc) => {
+        if (gc !== null) {
+            const hooks = new gc.AsyncHooks();
+            gc.applyHooks(plugins, (p) => p.grafast?.hooks, (name, fn, _plugin) => {
+                hooks.hook(name, fn);
+            });
+            resolvedPreset[$$hooksForPreset] = hooks;
+            return callback(hooks);
+        }
+        else {
+            resolvedPreset[$$hooksForPreset] = null;
+            return callback(null);
+        }
+    });
+}
+exports.withHooks = withHooks;
+function hook(resolvedPreset, hookName, ...args) {
+    if (resolvedPreset[$$skipHooks]?.[hookName]) {
+        return;
+    }
+    return withHooks(resolvedPreset, (hooks) => {
+        if (hooks !== null) {
+            if (hooks.callbacks[hookName] !== undefined) {
+                return hooks.process(hookName, ...args);
+            }
+            else {
+                if (!resolvedPreset[$$skipHooks]) {
+                    resolvedPreset[$$skipHooks] = Object.create(null);
+                }
+                resolvedPreset[$$skipHooks][hookName] = true;
+                return;
+            }
+        }
+        else {
+            if (!resolvedPreset[$$skipHooks]) {
+                resolvedPreset[$$skipHooks] = Object.create(null);
+            }
+            resolvedPreset[$$skipHooks][hookName] = true;
+            return;
+        }
+    });
+}
+exports.hook = hook;
+//# sourceMappingURL=config.js.map

package/dist/constraints.js

@@ -0,0 +1,72 @@
+"use strict";
+// PERF: optimise constraint matching, e.g. by collapsing redundant constraints
+// and then compiling (JIT-style) remaining constraints into a function using
+// tamedevil
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchesConstraints = void 0;
+function valueAtPath(object, path) {
+    let value = object;
+    for (let i = 0, l = path.length; i < l; i++) {
+        const key = path[i];
+        const expectArray = typeof key === "number";
+        const isArray = Array.isArray(value);
+        if (expectArray !== isArray) {
+            return undefined;
+        }
+        else {
+            if (value == null) {
+                return undefined;
+            }
+            value = value[key];
+            if (typeof value === "undefined") {
+                return undefined;
+            }
+        }
+    }
+    return value;
+}
+/**
+ * Implements the `MatchesConstraint` algorithm.
+ */
+function matchesConstraint(constraint, object) {
+    const value = valueAtPath(object, constraint.path);
+    switch (constraint.type) {
+        case "length": {
+            return Array.isArray(value) && value.length === constraint.expectedLength;
+        }
+        case "exists": {
+            return (value !== undefined) === constraint.exists;
+        }
+        case "equal": {
+            return (value === constraint.expectedValue) === constraint.pass;
+        }
+        case "value": {
+            return value === constraint.value;
+        }
+        case "isEmpty": {
+            const isEmpty = typeof value === "object" &&
+                value !== null &&
+                Object.keys(value).length === 0;
+            return isEmpty === constraint.isEmpty;
+        }
+        default: {
+            const never = constraint;
+            throw new Error(`Unsupported constraint type '${never.type}'`);
+        }
+    }
+}
+/**
+ * Implements the `MatchesConstraints` algorithm.
+ */
+function matchesConstraints(constraints, object) {
+    // In my testing, verbose loops are still about 20% faster than for...of
+    for (let i = 0, l = constraints.length; i < l; i++) {
+        const constraint = constraints[i];
+        if (!matchesConstraint(constraint, object)) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.matchesConstraints = matchesConstraints;
+//# sourceMappingURL=constraints.js.map

package/dist/deferred.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defer = void 0;
+function NOOP() { }
+/**
+ * Returns a promise that can be `.resolve()`-ed or `.reject()`-ed at a later
+ * time.
+ */
+function defer() {
+    let resolve;
+    let reject;
+    const promise = new Promise((_resolve, _reject) => {
+        resolve = _resolve;
+        reject = _reject;
+    });
+    promise.resolve = resolve;
+    promise.reject = reject;
+    // PERF: this is to avoid unhandledPromiseRejection errors; generally
+    // deferred errors are handled at a later time (or can be safely ignored if
+    // another error wins). Maybe there's a better way?
+    promise.then(null, NOOP);
+    return promise;
+}
+exports.defer = defer;
+//# sourceMappingURL=deferred.js.map

package/dist/dev.d.ts

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

package/dist/dev.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noop = exports.isTest = exports.isDev = void 0;
+/**
+ * @internal
+ */
+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.d.ts

@@ -1,5 +1,5 @@
 import type { Bucket } from "../bucket.js";
-import type { ExecutableStep, ModifierStep, UnbatchedExecutableStep } from "../step";
+import type { ExecutableStep } from "../step";
 import type { OperationPlan } from "./OperationPlan";
 /** Non-branching, non-deferred */
 export interface LayerPlanReasonRoot {
@@ -71,43 +71,6 @@ export type HasParent<A extends LayerPlanReason> = A extends any ? A extends {
     parentStep: ExecutableStep;
 } ? A : never : never;
 export type LayerPlanReasonsWithParentStep = HasParent<LayerPlanReason>;
-/** @internal */
-export interface LayerPlanPhase {
-    /**
-     * If true, we should check before the layer plan executes to see if the
-     * execution has already timed out.
-     *
-     * @see {@link RequestTools.stopTime}
-     */
-    checkTimeout: boolean;
-    /**
-     * A list of steps that can be ran in parallel at this point, since all
-     * their previous dependencies have already been satisfied.
-     */
-    normalSteps: Array<{
-        step: ExecutableStep;
-    }> | undefined;
-    /**
-     * A list of 'isSyncAndSafe' steps with unbatchedExecute methods that can be
-     * ran once the `normalSteps` have completed; they must only depend on steps
-     * that have already been executed before them (including previous
-     * unbatchedSyncAndSafeSteps in the same list).
-     */
-    unbatchedSyncAndSafeSteps: Array<{
-        step: UnbatchedExecutableStep;
-        /**
-         * Store the result of the step here if you want - useful to avoid lookups
-         * and when there's no storage. HIGHLY VOLATILE, will not survive a tick!
-         */
-        scratchpad: any;
-    }> | undefined;
-    /**
-     * Optimization - a digest of all steps in normalSteps and unbatchedSyncAndSafeSteps
-     *
-     * @internal
-     */
-    _allSteps: ExecutableStep[];
-}
 /**
  * A LayerPlan represents (via "reason") either the root (root), when something
  * happens at a later time (mutationField, defer), when plurality changes
@@ -138,58 +101,6 @@ export declare class LayerPlan<TReason extends LayerPlanReason = LayerPlanReason
     parentLayerPlan: LayerPlan | null;
     readonly reason: TReason;
     id: number;
-    /**
-     * Every layer plan has a "root step" that shapes the value the layer
-     * returns. Note that this step may be dependent on other steps included in
-     * the LayerPlan, or could be provided externally.
-     *
-     * The root step is different for different layer step reasons:
-     *
-     * - root: the `operationPlan.rootValue`
-     * - listItem: the `__ItemStep`
-     * - stream: also the `__ItemStep`
-     * - subscription: also the `__ItemStep`
-     * - mutationField: the result plan of the mutation field
-     * - defer: the parent layer's rootStep (defer always results in an object, unless an error occurs)
-     * - polymorphic: the plan for the particular type
-     * - subroutine: the result (returned) plan of the subroutine
-     *
-     * @internal
-     */
-    readonly rootStep: ExecutableStep | 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
-     * reference them?
-     *
-     * @internal
-     */
-    copyStepIds: number[];
-    /** @internal */
-    children: LayerPlan[];
-    /** @internal */
-    steps: ExecutableStep[];
-    /** @internal */
-    pendingSteps: ExecutableStep[];
-    /**
-     * Describes the order in which the steps within this LayerPlan are executed.
-     *
-     * Special attention must be paid to steps that have side effects.
-     *
-     * @internal
-     */
-    phases: Array<LayerPlanPhase>;
-    /**
-     * The list of layerPlans that steps added to this LayerPlan may depend upon.
-     * Note this includes self, so it has one more entry than `depth`.
-     *
-     * ```
-     * this.ancestry[this.depth] === this;
-     * ```
-     *
-     * @internal
-     */
-    ancestry: LayerPlan[];
     /** How "deep" this layer plan is (how many ancestors it has). The root layer plan has a depth of 0. */
     depth: number;
     /** The depth at which a "defer boundary" occurs (OperationPlan.getPeers cannot pass a defer boundary), or 0. */
@@ -203,12 +114,6 @@ export declare class LayerPlan<TReason extends LayerPlanReason = LayerPlanReason
     toString(): string;
     print(depth?: number): string;
     setRootStep($root: ExecutableStep): void;
-    /** @internal Use plan.getStep(id) instead. */
-    getStep(id: number, requestingStep: ExecutableStep): ExecutableStep;
-    /** @internal */
-    _addStep(step: ExecutableStep): number;
-    /** @internal */
-    _addModifierStep(step: ModifierStep<any>): string;
     finalize(): void;
     newBucket(parentBucket: Bucket): Bucket | null;
 }