grafast 0.1.1-beta.9 → 1.0.0-rc.2

package/README.md

@@ -50,12 +50,7 @@ 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.d.ts

@@ -1,9 +1,6 @@
 import type { ExecutionArgs } from "graphql";
-/**
- * Applies Graphile Config hooks to your GraphQL request, e.g. to
- * populate context or similar.
- *
- * @experimental
- */
-export declare function hookArgs(rawArgs: ExecutionArgs, resolvedPreset: GraphileConfig.ResolvedPreset, ctx: Partial<Grafast.RequestContext>): Grafast.ExecutionArgs | PromiseLike<Grafast.ExecutionArgs>;
+import type { GrafastExecutionArgs, PromiseOrDirect } from "./interfaces.js";
+/** @deprecated Pass `resolvedPreset` and `requestContext` via args directly */
+export declare function hookArgs(rawArgs: ExecutionArgs, resolvedPreset: GraphileConfig.ResolvedPreset, ctx: Partial<Grafast.RequestContext>): PromiseOrDirect<Grafast.ExecutionArgs>;
+export declare function hookArgs(rawArgs: GrafastExecutionArgs): PromiseOrDirect<Grafast.ExecutionArgs>;
 //# sourceMappingURL=args.d.ts.map

package/dist/args.js

@@ -1,62 +1,77 @@
 "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");
+exports.hookArgs = hookArgs;
+const constants_js_1 = require("./constants.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.
  *
  * @experimental
  */
-function hookArgs(rawArgs, resolvedPreset, ctx) {
+function hookArgs(rawArgs, legacyResolvedPreset, legacyCtx) {
+    if (legacyResolvedPreset !== undefined) {
+        rawArgs.resolvedPreset = legacyResolvedPreset;
+    }
+    if (legacyCtx !== undefined) {
+        rawArgs.requestContext = rawArgs.requestContext ?? legacyCtx;
+    }
+    const { middleware: rawMiddleware, resolvedPreset, contextValue: rawContextValue, } = rawArgs;
+    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);
+    if (rawMiddleware === undefined) {
+        rawArgs.middleware = middleware;
+    }
     const args = rawArgs;
     // Assert that args haven't already been hooked
-    if (args[interfaces_js_1.$$hooked]) {
+    if (args[constants_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);
+    args[constants_js_1.$$hooked] = true;
+    if (middleware != null) {
+        return middleware.run("prepareArgs", { args }, finalizeWithEvent);
+    }
+    else {
+        return finalize(args);
+    }
+}
+function finalize(args) {
+    const userContext = args.resolvedPreset?.grafast?.context;
+    const contextValue = args.contextValue;
+    if (typeof userContext === "function") {
+        const result = userContext(args.requestContext ?? EMPTY_OBJECT, args);
+        if ((0, utils_js_1.isPromiseLike)(result)) {
+            // Deliberately shadowed 'result'
+            return result.then((result) => {
+                Object.assign(contextValue, result);
                 return args;
-            }
-        }
-        else if (typeof userContext === "object" && userContext !== null) {
-            Object.assign(args.contextValue, userContext);
-            return args;
+            });
         }
         else {
+            Object.assign(contextValue, result);
             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);
+    else if (typeof userContext === "object" && userContext !== null) {
+        Object.assign(contextValue, userContext);
+        return args;
+    }
+    else {
+        return args;
+    }
+}
+function finalizeWithEvent(event) {
+    return finalize(event.args);
 }
-exports.hookArgs = hookArgs;
 //# sourceMappingURL=args.js.map

package/dist/assert.js

@@ -6,19 +6,18 @@
  * https://github.com/facebook/jest/issues/2549
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.strictEqual = exports.ok = void 0;
+exports.ok = ok;
+exports.strictEqual = strictEqual;
 /** 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/config.d.ts

@@ -1,19 +1,2 @@
-import type { AsyncHooks, PluginHook } from "graphile-config";
 export declare const NULL_PRESET: GraphileConfig.ResolvedPreset;
-type GraphileConfigModule = typeof import("graphile-config");
-type PromiseOrValue<T> = T | Promise<T>;
-export declare function withGraphileConfig<T>(callback: (graphileConfig: GraphileConfigModule | null) => PromiseOrValue<T>): PromiseOrValue<T>;
-declare const $$skipHooks: unique symbol;
-declare const $$hooksForPreset: unique symbol;
-declare global {
-    namespace GraphileConfig {
-        interface ResolvedPreset {
-            [$$hooksForPreset]?: null | AsyncHooks<GraphileConfig.GrafastHooks>;
-            [$$skipHooks]?: Record<string, boolean>;
-        }
-    }
-}
-export declare function withHooks<TResult>(resolvedPreset: GraphileConfig.ResolvedPreset, callback: (hooks: AsyncHooks<GraphileConfig.GrafastHooks> | null) => PromiseOrValue<TResult>): PromiseOrValue<TResult>;
-export declare function hook<THookName extends keyof GraphileConfig.GrafastHooks>(resolvedPreset: GraphileConfig.ResolvedPreset, hookName: THookName, ...args: Parameters<GraphileConfig.GrafastHooks[THookName] extends PluginHook<infer U> ? U : never>): PromiseOrValue<void>;
-export {};
 //# sourceMappingURL=config.d.ts.map

package/dist/config.js

@@ -1,99 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hook = exports.withHooks = exports.withGraphileConfig = exports.NULL_PRESET = void 0;
+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/constants.d.ts

@@ -0,0 +1,79 @@
+export declare const $$hooked: unique symbol;
+export declare const $$grafastContext: unique symbol;
+export declare const $$planResults: unique symbol;
+export declare const $$id: unique symbol;
+/** Return the value verbatim, don't execute */
+export declare const $$verbatim: unique symbol;
+/**
+ * If we're sure the data is the right shape and valid, we can set this key and
+ * it can be returned directly
+ */
+export declare const $$bypassGraphQL: unique symbol;
+export declare const $$data: unique symbol;
+/**
+ * For attaching additional metadata to the GraphQL execution result, for
+ * example details of the plan or SQL queries or similar that were executed.
+ */
+export declare const $$extensions: unique symbol;
+/**
+ * Set this key on a type if that type's serialization is idempotent (that is
+ * to say `serialize(serialize(thing)) === serialize(thing)`). This means we
+ * don't have to "roll-back" serialization if we need to fallback to graphql-js
+ * execution.
+ */
+export declare const $$idempotent: unique symbol;
+/**
+ * The event emitter used for outputting execution events.
+ */
+export declare const $$eventEmitter: unique symbol;
+/**
+ * Used to indicate that an array has more results available via a stream.
+ */
+export declare const $$streamMore: unique symbol;
+export declare const $$proxy: unique symbol;
+/**
+ * If an error has this property set then it's safe to send through to the user
+ * without being masked.
+ */
+export declare const $$safeError: unique symbol;
+/** The layerPlan used as a subroutine for this step */
+export declare const $$subroutine: unique symbol;
+/** For tracking the timeout a TimeoutError happened from */
+export declare const $$timeout: unique symbol;
+/** For tracking _when_ the timeout happened (because once the JIT has warmed it might not need so long) */
+export declare const $$ts: unique symbol;
+export declare const $$queryCache: unique symbol;
+/**
+ * We store the cache directly onto the GraphQLSchema so that it gets garbage
+ * collected along with the schema when it's not needed any more. To do so, we
+ * attach it using this symbol.
+ */
+export declare const $$cacheByOperation: unique symbol;
+export declare const $$contextPlanCache: unique symbol;
+/**
+ * A bitwise number representing a number of flags:
+ *
+ * - 0: normal execution value
+ * - 1: errored (trappable)
+ * - 2: null (trappable)
+ * - 4: inhibited (trappable)
+ * - 8: disabled due to polymorphism (untrappable)
+ * - 16: stopped (untrappable) - e.g. due to fatal (unrecoverable) error
+ * - 32: ...
+ */
+export type ExecutionEntryFlags = number & {
+    readonly tsBrand?: unique symbol;
+};
+export declare const NO_FLAGS: ExecutionEntryFlags;
+export declare const FLAG_ERROR: ExecutionEntryFlags;
+export declare const FLAG_NULL: ExecutionEntryFlags;
+export declare const FLAG_INHIBITED: ExecutionEntryFlags;
+export declare const FLAG_POLY_SKIPPED: ExecutionEntryFlags;
+export declare const FLAG_STOPPED: ExecutionEntryFlags;
+export declare const ALL_FLAGS: ExecutionEntryFlags;
+/** By default, accept null values as an input */
+export declare const DEFAULT_ACCEPT_FLAGS: ExecutionEntryFlags;
+export declare const TRAPPABLE_FLAGS: ExecutionEntryFlags;
+export declare const DEFAULT_FORBIDDEN_FLAGS: ExecutionEntryFlags;
+export declare const FORBIDDEN_BY_NULLABLE_BOUNDARY_FLAGS: ExecutionEntryFlags;
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FORBIDDEN_BY_NULLABLE_BOUNDARY_FLAGS = exports.DEFAULT_FORBIDDEN_FLAGS = exports.TRAPPABLE_FLAGS = exports.DEFAULT_ACCEPT_FLAGS = exports.ALL_FLAGS = exports.FLAG_STOPPED = exports.FLAG_POLY_SKIPPED = exports.FLAG_INHIBITED = exports.FLAG_NULL = exports.FLAG_ERROR = exports.NO_FLAGS = exports.$$contextPlanCache = exports.$$cacheByOperation = exports.$$queryCache = exports.$$deepDepSkip = exports.$$ts = exports.$$timeout = exports.$$subroutine = exports.$$safeError = exports.$$proxy = exports.$$streamMore = exports.$$eventEmitter = exports.$$idempotent = exports.$$extensions = exports.$$data = exports.$$bypassGraphQL = exports.$$verbatim = exports.$$id = exports.$$planResults = exports.$$grafastContext = exports.$$hooked = void 0;
+exports.$$hooked = Symbol("hookArgsApplied");
+exports.$$grafastContext = Symbol("context");
+exports.$$planResults = Symbol("planResults");
+exports.$$id = Symbol("id");
+/** Return the value verbatim, don't execute */
+exports.$$verbatim = Symbol("verbatim");
+/**
+ * If we're sure the data is the right shape and valid, we can set this key and
+ * it can be returned directly
+ */
+exports.$$bypassGraphQL = Symbol("bypassGraphQL");
+exports.$$data = Symbol("data");
+/**
+ * For attaching additional metadata to the GraphQL execution result, for
+ * example details of the plan or SQL queries or similar that were executed.
+ */
+exports.$$extensions = Symbol("extensions");
+/**
+ * Set this key on a type if that type's serialization is idempotent (that is
+ * to say `serialize(serialize(thing)) === serialize(thing)`). This means we
+ * don't have to "roll-back" serialization if we need to fallback to graphql-js
+ * execution.
+ */
+exports.$$idempotent = Symbol("idempotent");
+/**
+ * The event emitter used for outputting execution events.
+ */
+exports.$$eventEmitter = Symbol("executionEventEmitter");
+/**
+ * Used to indicate that an array has more results available via a stream.
+ */
+exports.$$streamMore = Symbol("streamMore");
+exports.$$proxy = Symbol("proxy");
+/**
+ * If an error has this property set then it's safe to send through to the user
+ * without being masked.
+ */
+exports.$$safeError = Symbol("safeError");
+/** The layerPlan used as a subroutine for this step */
+exports.$$subroutine = Symbol("subroutine");
+/** For tracking the timeout a TimeoutError happened from */
+exports.$$timeout = Symbol("timeout");
+/** For tracking _when_ the timeout happened (because once the JIT has warmed it might not need so long) */
+exports.$$ts = Symbol("timestamp");
+/**
+ * @internal
+ */
+exports.$$deepDepSkip = Symbol("deepDepSkip_experimental");
+exports.$$queryCache = Symbol("queryCache");
+/**
+ * We store the cache directly onto the GraphQLSchema so that it gets garbage
+ * collected along with the schema when it's not needed any more. To do so, we
+ * attach it using this symbol.
+ */
+exports.$$cacheByOperation = Symbol("cacheByOperation");
+exports.$$contextPlanCache = Symbol("contextPlanCache");
+function flag(f) {
+    return f;
+}
+exports.NO_FLAGS = flag(0); // 0
+exports.FLAG_ERROR = flag(1 << 0); // 1
+exports.FLAG_NULL = flag(1 << 1); // 2
+exports.FLAG_INHIBITED = flag(1 << 2); // 4
+exports.FLAG_POLY_SKIPPED = flag(1 << 3); // 8
+exports.FLAG_STOPPED = flag(1 << 4); // 16
+exports.ALL_FLAGS = flag(exports.FLAG_ERROR | exports.FLAG_NULL | exports.FLAG_INHIBITED | exports.FLAG_POLY_SKIPPED | exports.FLAG_STOPPED);
+/** By default, accept null values as an input */
+exports.DEFAULT_ACCEPT_FLAGS = flag(exports.FLAG_NULL);
+exports.TRAPPABLE_FLAGS = flag(exports.FLAG_ERROR | exports.FLAG_NULL | exports.FLAG_INHIBITED);
+exports.DEFAULT_FORBIDDEN_FLAGS = flag(exports.ALL_FLAGS & ~exports.DEFAULT_ACCEPT_FLAGS);
+exports.FORBIDDEN_BY_NULLABLE_BOUNDARY_FLAGS = flag(exports.FLAG_NULL | exports.FLAG_POLY_SKIPPED);
+// TODO: make `FORBIDDEN_BY_NULLABLE_BOUNDARY_FLAGS = flag(FLAG_ERROR | FLAG_NULL | FLAG_POLY_SKIPPED | FLAG_INHIBITED | FLAG_STOPPED);`
+// Currently this isn't enabled because the bucket has to exist for the output
+// plan to throw the error; really the root should be evaluated before
+// descending into the output plan rather than as part of descending?
+//# sourceMappingURL=constants.js.map

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

@@ -3,7 +3,7 @@
 // and then compiling (JIT-style) remaining constraints into a function using
 // tamedevil
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.matchesConstraints = void 0;
+exports.matchesConstraints = matchesConstraints;
 function valueAtPath(object, path) {
     let value = object;
     for (let i = 0, l = path.length; i < l; i++) {
@@ -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}'`);
@@ -68,5 +107,4 @@ function matchesConstraints(constraints, object) {
     }
     return true;
 }
-exports.matchesConstraints = matchesConstraints;
 //# sourceMappingURL=constraints.js.map

package/dist/deferred.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defer = void 0;
+exports.defer = defer;
 function NOOP() { }
 /**
  * Returns a promise that can be `.resolve()`-ed or `.reject()`-ed at a later
@@ -21,5 +21,4 @@ function defer() {
     promise.then(null, NOOP);
     return promise;
 }
-exports.defer = defer;
 //# sourceMappingURL=deferred.js.map

package/dist/dev.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.noop = exports.isTest = exports.isDev = void 0;
+exports.isTest = exports.isDev = void 0;
+exports.noop = noop;
 /**
  * @internal
  */
@@ -13,15 +14,12 @@ const mode = graphileEnv !== undefined ? graphileEnv : nodeEnv;
 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.`);
+else if (exports.isDev && !exports.isTest && typeof graphileEnv === "undefined") {
+    console.warn(`Grafast is running in development mode due to \`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. To remove this warning, make this explicit with \`GRAPHILE_ENV=development\` envvar.`);
 }
 //# sourceMappingURL=dev.js.map