grafast 0.1.1-beta.0 → 0.1.1-beta.2

package/README.md

@@ -52,9 +52,8 @@ 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>
+</tr><tr>
 <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></table>

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.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.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noop = exports.isDev = void 0;
+/**
+ * @internal
+ */
+exports.isDev = typeof process !== "undefined" && process.env.GRAPHILE_ENV === "development";
+function noop() { }
+exports.noop = noop;
+//# sourceMappingURL=dev.js.map