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

package/dist/engine/executeOutputPlan.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeOutputPlan = void 0;
+const tslib_1 = require("tslib");
+const assert = tslib_1.__importStar(require("../assert.js"));
+const dev_js_1 = require("../dev.js");
+/**
+ * @internal
+ */
+function executeOutputPlan(ctx, outputPlan, bucket, bucketIndex, outputDataAsString) {
+    if (dev_js_1.isDev) {
+        assert.strictEqual(bucket.isComplete, true, "Can only process an output plan for a completed bucket");
+    }
+    // PERF: feels like this path could be done more efficiently
+    const mutablePath = ["SOMEONE_FORGOT_TO_SLICE_THE_PATH!", ...ctx.path];
+    return outputDataAsString
+        ? outputPlan.executeString(ctx.root, mutablePath, bucket, bucketIndex)
+        : outputPlan.execute(ctx.root, mutablePath, bucket, bucketIndex);
+}
+exports.executeOutputPlan = executeOutputPlan;
+//# sourceMappingURL=executeOutputPlan.js.map

package/dist/engine/lib/withGlobalLayerPlan.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.currentPolymorphicPaths = exports.currentLayerPlan = exports.withGlobalLayerPlan = void 0;
+let globalData_layerPlan = undefined;
+let globalData_polymorphicPaths = undefined;
+function withGlobalLayerPlan(layerPlan, polymorphicPaths, callback, callbackThis, ...callbackArgs) {
+    const oldLayerPlan = globalData_layerPlan;
+    globalData_layerPlan = layerPlan;
+    const oldPolymorphicPaths = globalData_polymorphicPaths;
+    globalData_polymorphicPaths = polymorphicPaths;
+    try {
+        return callback.apply(callbackThis, callbackArgs);
+    }
+    finally {
+        globalData_layerPlan = oldLayerPlan;
+        globalData_polymorphicPaths = oldPolymorphicPaths;
+    }
+}
+exports.withGlobalLayerPlan = withGlobalLayerPlan;
+function currentLayerPlan() {
+    if (globalData_layerPlan === undefined) {
+        throw new Error(
+        // Must only be called from inside `withGlobalLayerPlan`!
+        "Now is not a valid time to call `currentLayerPlan`. This error typically occurs when you attempt to call a Grafast step function from outside of the planning lifecycle - it's important to note that Grafast plans must be resolved synchronously, so check for 'async' or 'setTimeout' or any location where a step function is called outside of a plan resolver. For more information, read about plan resolvers: https://grafast.org/grafast/plan-resolvers");
+    }
+    return globalData_layerPlan;
+}
+exports.currentLayerPlan = currentLayerPlan;
+function currentPolymorphicPaths() {
+    if (globalData_polymorphicPaths === undefined) {
+        throw new Error("GrafastInternalError<b0b05743-8b21-42c6-9b53-925013d88bd1>: currentPolymorphicPaths called out of turn; must only called within a withGlobalLayerPlan callback");
+    }
+    return globalData_polymorphicPaths;
+}
+exports.currentPolymorphicPaths = currentPolymorphicPaths;
+//# sourceMappingURL=withGlobalLayerPlan.js.map

package/dist/envelop.js

@@ -1,5 +1,73 @@
-// Convince Node to allow ESM named imports
-
-
-// Bundled module
-"use strict";!function(e,r){"object"==typeof exports&&"object"==typeof module?module.exports=r():"function"==typeof define&&define.amd?define([],r):"object"==typeof exports?exports.grafast=r():e.grafast=r()}(this,(()=>(this.webpackChunkgrafast=this.webpackChunkgrafast||[]).push([[764],{3837:(e,r,s)=>{Object.defineProperty(r,"__esModule",{value:!0}),r.useMoreDetailedErrors=r.useGrafast=void 0;const t=s(6587),n=s(6522),a=s(680);function o(e,r){if(!1===e||Array.isArray(e)&&0===e.length)return;const s=Array.isArray(r)?r.join(","):r;if(!s)return;const t=s.split(",");return!0===e||void 0===e?t:e.filter((e=>t.includes(e)))}r.useGrafast=(e={})=>{const{explainAllowed:r=!0}=e;return{async onExecute(e){const s=e.args.contextValue?.req?.headers["x-graphql-explain"],n=o(r,s);e.setExecuteFn((e=>(0,t.execute)(e,{grafast:{explain:n}})))},async onSubscribe(e){const s=e.args.contextValue,t=(s?.req?.headers||s?.request?.headers||s?.connectionParams)?.["x-graphql-explain"],n=o(r,t);e.setSubscribeFn((async e=>(0,a.subscribe)(e,{grafast:{explain:n}})))}}};r.useMoreDetailedErrors=()=>({onExecute:()=>({onExecuteDone({result:e}){"errors"in e&&e.errors&&(e.errors=e.errors.map((e=>{const r=e.toJSON();return Object.assign(r,{message:(0,n.stripAnsi)(r.message),extensions:{stack:(0,n.stripAnsi)(e.stack??"").split("\n")}})})))}})})}},e=>{var r;return r=3837,e(e.s=r)}])));
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMoreDetailedErrors = exports.useGrafast = void 0;
+const execute_js_1 = require("./execute.js");
+const stripAnsi_js_1 = require("./stripAnsi.js");
+const subscribe_js_1 = require("./subscribe.js");
+function processExplain(explainAllowed, explainHeaders) {
+    if (explainAllowed === false ||
+        (Array.isArray(explainAllowed) && explainAllowed.length === 0)) {
+        return undefined;
+    }
+    const explainHeader = Array.isArray(explainHeaders)
+        ? explainHeaders.join(",")
+        : explainHeaders;
+    if (!explainHeader) {
+        return undefined;
+    }
+    const explainParts = explainHeader.split(",");
+    if (explainAllowed === true || explainAllowed === undefined) {
+        return explainParts;
+    }
+    // Assumption: explainAllowed is relatively short (and unique).
+    // PERF: there's probably a faster way to do this...
+    return explainAllowed.filter((p) => explainParts.includes(p));
+}
+/**
+ * An Envelop plugin that uses Grafast to prepare and execute the GraphQL
+ * query.
+ */
+const useGrafast = (options = {}) => {
+    const { explainAllowed = true } = options;
+    return {
+        async onExecute(opts) {
+            const explainHeaders = opts.args.contextValue?.req?.headers["x-graphql-explain"];
+            const explain = processExplain(explainAllowed, explainHeaders);
+            opts.setExecuteFn((args) => (0, execute_js_1.execute)(args, {
+                grafast: { explain },
+            }));
+        },
+        async onSubscribe(opts) {
+            const ctx = opts.args.contextValue;
+            const explainHeaders = (ctx?.req?.headers ||
+                ctx?.request?.headers ||
+                ctx?.connectionParams)?.["x-graphql-explain"];
+            const explain = processExplain(explainAllowed, explainHeaders);
+            opts.setSubscribeFn(async (args) => (0, subscribe_js_1.subscribe)(args, {
+                grafast: { explain },
+            }));
+        },
+    };
+};
+exports.useGrafast = useGrafast;
+/**
+ * An Envelop plugin that will make any GraphQL errors easier to read from
+ * inside of GraphiQL.
+ */
+const useMoreDetailedErrors = () => ({
+    onExecute: () => ({
+        onExecuteDone({ result }) {
+            if ("errors" in result && result.errors) {
+                result.errors = result.errors.map((e) => {
+                    const obj = e.toJSON();
+                    return Object.assign(obj, {
+                        message: (0, stripAnsi_js_1.stripAnsi)(obj.message),
+                        extensions: { stack: (0, stripAnsi_js_1.stripAnsi)(e.stack ?? "").split("\n") },
+                    });
+                });
+            }
+        },
+    }),
+});
+exports.useMoreDetailedErrors = useMoreDetailedErrors;
+//# sourceMappingURL=envelop.js.map

package/dist/error.js

@@ -0,0 +1,62 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSafeError = exports.SafeError = exports.isGrafastError = exports.newGrafastError = exports._GrafastError = exports.$$error = void 0;
+const interfaces_js_1 = require("./interfaces.js");
+exports.$$error = Symbol("isGrafastError");
+// IMPORTANT: this WILL NOT WORK when compiled down to ES5. It requires ES6+
+// native class support.
+/**
+ * When an error occurs during plan execution we wrap it in a GrafastError so
+ * that we can pass it around as a value.  It gets unwrapped and thrown in the
+ * grafast resolver.
+ *
+ * @internal
+ */
+const _GrafastError = class GrafastError extends Error {
+    static { _a = exports.$$error; }
+    constructor(originalError, planId) {
+        if (originalError instanceof exports._GrafastError) {
+            throw new Error("GrafastInternalError<62505509-8b21-4ef7-80f5-d0f99873174b>: attempted to wrap a GrafastError with a GrafastError.");
+        }
+        const message = originalError?.message;
+        super(message);
+        this[_a] = true;
+        Object.setPrototypeOf(this, GrafastError.prototype);
+        this.originalError = originalError;
+        this.extensions = { grafast: { planId } };
+    }
+};
+exports._GrafastError = _GrafastError;
+/**
+ * DO NOT ALLOW CONSTRUCTION OF ERRORS OUTSIDE OF THIS MODULE!
+ *
+ * @internal
+ */
+function newGrafastError(error, planId) {
+    return new exports._GrafastError(error, planId);
+}
+exports.newGrafastError = newGrafastError;
+/**
+ * Is the given value a GrafastError? This is the only public API that people
+ * should use for looking at GrafastErrors.
+ */
+function isGrafastError(value) {
+    return typeof value === "object" && value !== null && exports.$$error in value;
+}
+exports.isGrafastError = isGrafastError;
+class SafeError extends Error {
+    static { _b = interfaces_js_1.$$safeError; }
+    constructor(message, extensions = undefined, errorOptions) {
+        super(message, errorOptions);
+        this.extensions = extensions;
+        this[_b] = true;
+        Object.setPrototypeOf(this, SafeError.prototype);
+    }
+}
+exports.SafeError = SafeError;
+function isSafeError(error) {
+    return error[interfaces_js_1.$$safeError];
+}
+exports.isSafeError = isSafeError;
+//# sourceMappingURL=error.js.map

package/dist/establishOperationPlan.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.establishOperationPlan = void 0;
+const tslib_1 = require("tslib");
+const lru_1 = tslib_1.__importDefault(require("@graphile/lru"));
+const debug_1 = tslib_1.__importDefault(require("debug"));
+const constraints_js_1 = require("./constraints.js");
+const dev_js_1 = require("./dev.js");
+const index_js_1 = require("./index.js");
+const interfaces_js_1 = require("./interfaces.js");
+const timeSource_js_1 = require("./timeSource.js");
+const debug = (0, debug_1.default)("grafast:establishOperationPlan");
+// How long is a timeout valid for? Here I've set it to 60 seconds.
+const TIMEOUT_TIMEOUT = (typeof process !== "undefined" &&
+    typeof process.env.GRAFAST_TIMEOUT_VALIDITY_MS === "string"
+    ? parseInt(process.env.GRAFAST_TIMEOUT_VALIDITY_MS, 10)
+    : null) || 60000;
+// OPTIMIZE: we should consider increasing the timeout once the process has been
+// running a while (since the JIT should have kicked in) - we could even use
+// `setTimeout` to trigger it after certain amount of time elapsed.
+/**
+ * This is a development-only validation to check fragments do, in fact, match
+ * - even if the objects themselves differ.
+ */
+function reallyAssertFragmentsMatch(oldFragments, fragments) {
+    if (oldFragments !== fragments) {
+        debug("fragments aren't `===` for same operation");
+        // Consistency check - we assume that if the operation is the same then
+        // the fragments will be, but this may not be the case depending on if
+        // GraphQL.js caches the operation node.
+        const oldKeys = Object.keys(oldFragments).sort();
+        const newKeys = Object.keys(fragments).sort();
+        const oldKeyStr = oldKeys.join(",");
+        const newKeyStr = newKeys.join(",");
+        if (oldKeyStr.length !== newKeyStr.length) {
+            throw new Error(`Inconsistency error: operation matches, but fragment keys differ: '${oldKeyStr}' != '${newKeyStr}'.`);
+        }
+        for (const key of newKeys) {
+            if (oldFragments[key] !== fragments[key]) {
+                throw new Error(`Inconsistency error: operation matches, fragment names match, but fragment '${key}' is not '===' to the previous value.`);
+            }
+        }
+    }
+}
+// Optimise this away in production.
+const assertFragmentsMatch = !dev_js_1.isDev ? dev_js_1.noop : reallyAssertFragmentsMatch;
+/**
+ * Implements the `IsOpPlanCompatible` algorithm.
+ *
+ * @remarks Due to the optimisation in `establishOperationPlan`, the schema, document
+ * and operationName checks have already been performed.
+ */
+function isOperationPlanCompatible(operationPlan, variableValues, context, rootValue) {
+    const { variableValuesConstraints, contextConstraints, rootValueConstraints, } = operationPlan;
+    if (!(0, constraints_js_1.matchesConstraints)(variableValuesConstraints, variableValues)) {
+        return false;
+    }
+    if (!(0, constraints_js_1.matchesConstraints)(contextConstraints, context)) {
+        return false;
+    }
+    if (!(0, constraints_js_1.matchesConstraints)(rootValueConstraints, rootValue)) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Implements the `EstablishOpPlan` algorithm.
+ *
+ * @remarks Though EstablishOpPlan accepts document and operationName, we
+ * instead accept operation and fragments since they're easier to get a hold of
+ * in GraphQL.js.
+ */
+// eslint-disable-next-line @typescript-eslint/ban-types
+function establishOperationPlan(schema, operation, fragments, variableValues, context, rootValue, planningTimeout = null) {
+    let cacheByOperation = schema.extensions.grafast?.[interfaces_js_1.$$cacheByOperation];
+    let cache = cacheByOperation?.get(operation);
+    // These two variables to make it easy to trim the linked list later.
+    let count = 0;
+    let lastButOneItem = null;
+    if (cache !== undefined) {
+        // Dev-only validation
+        assertFragmentsMatch(cache.fragments, fragments);
+        let previousItem = null;
+        let linkedItem = cache.possibleOperationPlans;
+        while (linkedItem) {
+            const value = linkedItem.value;
+            if (value instanceof index_js_1.SafeError) {
+                if (value.extensions?.[interfaces_js_1.$$timeout] != null) {
+                    if (value.extensions[interfaces_js_1.$$ts] < timeSource_js_1.timeSource.now() - TIMEOUT_TIMEOUT) {
+                        // Remove this out of date timeout
+                        linkedItem = linkedItem.next;
+                        if (previousItem !== null) {
+                            previousItem.next = linkedItem;
+                        }
+                        else {
+                            cache.possibleOperationPlans = linkedItem;
+                        }
+                        continue;
+                    }
+                    if (planningTimeout !== null &&
+                        value.extensions[interfaces_js_1.$$timeout] >= planningTimeout) {
+                        // It was a timeout error - do not retry
+                        throw value;
+                    }
+                    else {
+                        // That's Not My Timeout, let's try again.
+                    }
+                }
+                else {
+                    // Not a timeout error - this will always fail in the same way?
+                    throw value;
+                }
+            }
+            else if (value instanceof Error) {
+                // Not a timeout error - this will always fail in the same way?
+                throw value;
+            }
+            else if (isOperationPlanCompatible(value, variableValues, context, rootValue)) {
+                // Hoist to top of linked list
+                if (previousItem !== null) {
+                    // Remove linkedItem from existing chain
+                    previousItem.next = linkedItem.next;
+                    // Add rest of chain after linkedItem
+                    linkedItem.next = cache.possibleOperationPlans;
+                    // linkedItem is now head of chain
+                    cache.possibleOperationPlans = linkedItem;
+                }
+                // We found a suitable OperationPlan - use that!
+                return value;
+            }
+            count++;
+            lastButOneItem = previousItem;
+            previousItem = linkedItem;
+            linkedItem = linkedItem.next;
+        }
+    }
+    // No suitable OperationPlan found, time to make one.
+    let operationPlan;
+    let error;
+    try {
+        operationPlan = new index_js_1.OperationPlan(schema, operation, fragments, variableValues, context, rootValue, planningTimeout);
+    }
+    catch (e) {
+        error = e;
+    }
+    // Store it to the cache
+    if (!cacheByOperation) {
+        if (!schema.extensions.grafast) {
+            schema.extensions.grafast = Object.create(null);
+        }
+        cacheByOperation = new lru_1.default({
+            maxLength: schema.extensions.grafast.operationsCacheMaxLength ?? 500,
+        });
+        schema.extensions.grafast[interfaces_js_1.$$cacheByOperation] = cacheByOperation;
+    }
+    const operationPlanOrError = operationPlan ?? error;
+    if (!cache) {
+        cache = {
+            fragments,
+            possibleOperationPlans: { value: operationPlanOrError, next: null },
+        };
+        cacheByOperation.set(operation, cache);
+    }
+    else {
+        const max = schema.extensions.grafast.operationOperationPlansCacheMaxLength ?? 50;
+        if (count >= max) {
+            // Remove the tail to ensure we never grow too big
+            lastButOneItem.next = null;
+            count--;
+            // LOGGING: we should announce this so that people know there's something that needs fixing in their schema (too much eval?)
+        }
+        // Add new operationPlan to top of the linked list.
+        cache.possibleOperationPlans = {
+            value: operationPlanOrError,
+            next: cache.possibleOperationPlans,
+        };
+    }
+    if (error !== undefined) {
+        throw error;
+    }
+    else {
+        return operationPlan;
+    }
+}
+exports.establishOperationPlan = establishOperationPlan;
+//# sourceMappingURL=establishOperationPlan.js.map

package/dist/execute.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execute = exports.withGrafastArgs = void 0;
+const tslib_1 = require("tslib");
+const eventemitter3_1 = tslib_1.__importDefault(require("eventemitter3"));
+const config_js_1 = require("./config.js");
+const inspect_js_1 = require("./inspect.js");
+const interfaces_js_1 = require("./interfaces.js");
+const prepare_js_1 = require("./prepare.js");
+const utils_js_1 = require("./utils.js");
+const isDev = typeof process !== "undefined" && process.env.NODE_ENV === "development";
+/**
+ * Used by `execute` and `subscribe`.
+ * @internal
+ */
+function withGrafastArgs(args, resolvedPreset, outputDataAsString) {
+    const options = resolvedPreset?.grafast;
+    if (isDev) {
+        if (args.rootValue != null &&
+            (typeof args.rootValue !== "object" ||
+                Object.keys(args.rootValue).length > 0)) {
+            throw new Error(`Grafast executor doesn't support there being a rootValue (found ${(0, inspect_js_1.inspect)(args.rootValue)})`);
+        }
+    }
+    if (args.rootValue == null) {
+        args.rootValue = Object.create(null);
+    }
+    if (typeof args.rootValue !== "object" || args.rootValue == null) {
+        throw new Error("Grafast requires that the 'rootValue' be an object");
+    }
+    const explain = options?.explain;
+    const shouldExplain = !!explain;
+    let unlisten = null;
+    if (shouldExplain) {
+        const eventEmitter = new eventemitter3_1.default();
+        const explainOperations = [];
+        args.rootValue = Object.assign(Object.create(null), args.rootValue, {
+            [interfaces_js_1.$$eventEmitter]: eventEmitter,
+            [interfaces_js_1.$$extensions]: {
+                explain: {
+                    operations: explainOperations,
+                },
+            },
+        });
+        const handleExplainOperation = ({ operation, }) => {
+            if (explain === true || (explain && explain.includes(operation.type))) {
+                explainOperations.push(operation);
+            }
+        };
+        eventEmitter.on("explainOperation", handleExplainOperation);
+        unlisten = () => {
+            eventEmitter.removeListener("explainOperation", handleExplainOperation);
+        };
+    }
+    const rootValue = (0, prepare_js_1.grafastPrepare)(args, {
+        explain: options?.explain,
+        outputDataAsString,
+        timeouts: options?.timeouts,
+    });
+    if (unlisten !== null) {
+        Promise.resolve(rootValue).then(unlisten, unlisten);
+    }
+    // Convert from PromiseOrDirect to PromiseOrValue
+    if ((0, utils_js_1.isPromiseLike)(rootValue)) {
+        return Promise.resolve(rootValue);
+    }
+    else {
+        return rootValue;
+    }
+}
+exports.withGrafastArgs = withGrafastArgs;
+/**
+ * Use this instead of GraphQL.js' execute method and we'll automatically
+ * run grafastPrepare for you and handle the result.
+ */
+function execute(args, resolvedPreset = config_js_1.NULL_PRESET, outputDataAsString = false) {
+    return withGrafastArgs(args, resolvedPreset, outputDataAsString);
+}
+exports.execute = execute;
+//# sourceMappingURL=execute.js.map

package/dist/exportAs.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportAsMany = exports.exportAs = void 0;
+const utils_js_1 = require("./utils.js");
+/**
+ * Marks that `thing` is exported from the `grafast` module as
+ * `exportName` so that `graphile-export` can convert references to `thing`
+ * into an `import` statement.
+ *
+ * @internal
+ */
+function exportAs(moduleName, thing, exportName) {
+    if (!("$$export" in thing)) {
+        Object.defineProperty(thing, "$$export", {
+            value: { moduleName, exportName },
+        });
+    }
+    else {
+        const e = thing.$$export;
+        if (e.moduleName !== moduleName) {
+            throw new Error(`Attempted to export ${thing} as '${moduleName}.${exportName}', but it's already exported as '${e.moduleName}.${e.exportName}' (module name mismatch)`);
+        }
+        if (typeof e.exportName === "string" || exportName === "string") {
+            if (e.exportName !== exportName) {
+                throw new Error(`Attempted to export ${thing} as '${moduleName}.${exportName}', but it's already exported as '${e.moduleName}.${e.exportName}' (export name mismatch)`);
+            }
+        }
+        else {
+            // Must be arrays
+            if (!Array.isArray(e.exportName) ||
+                !Array.isArray(exportName) ||
+                !(0, utils_js_1.arraysMatch)(e.exportName, exportName)) {
+                throw new Error(`Attempted to export ${thing} as '${moduleName}.${exportName}', but it's already exported as '${e.moduleName}.${e.exportName}' (export name path mismatch)`);
+            }
+        }
+    }
+    return thing;
+}
+exports.exportAs = exportAs;
+/**
+ * Marks that each value in `all` is exported from the `grafast`
+ * module as the key in the `all` object so that `graphile-export` can
+ * convert references to these values into `import` statements.
+ *
+ * @internal
+ */
+function exportAsMany(moduleName, all) {
+    for (const key of Object.keys(all)) {
+        const value = all[key];
+        if ((typeof value === "object" || typeof value === "function") &&
+            value !== null) {
+            exportAs(moduleName, all[key], key);
+        }
+    }
+}
+exports.exportAsMany = exportAsMany;
+//# sourceMappingURL=exportAs.js.map

package/dist/global.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDebug = exports.setDebug = void 0;
+let debug = false;
+function setDebug(newDebug) {
+    debug = newDebug;
+}
+exports.setDebug = setDebug;
+function getDebug() {
+    return debug;
+}
+exports.getDebug = getDebug;
+//# sourceMappingURL=global.js.map

package/dist/grafastGraphql.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.grafastSync = exports.grafast = void 0;
+const tslib_1 = require("tslib");
+const lru_1 = tslib_1.__importDefault(require("@graphile/lru"));
+const graphql = tslib_1.__importStar(require("graphql"));
+const error_js_1 = require("./error.js");
+const execute_js_1 = require("./execute.js");
+const index_js_1 = require("./index.js");
+const interfaces_js_1 = require("./interfaces.js");
+const utils_js_1 = require("./utils.js");
+const { GraphQLError, parse, Source, validate, validateSchema } = graphql;
+/** Rough average size per query */
+const CACHE_MULTIPLIER = 100000;
+const MEGABYTE = 1024 * 1024;
+const queryCacheMaxSizeInBytes = 50 * MEGABYTE;
+const defaultQueryCacheMaxSize = Math.max(2, Math.ceil(queryCacheMaxSizeInBytes / CACHE_MULTIPLIER));
+// If we can use crypto to create a hash, great. Otherwise just use the string.
+let calculateQueryHash;
+try {
+    let lastString;
+    let lastHash;
+    const createHash = require("crypto").createHash;
+    if (typeof createHash !== "function") {
+        throw new Error("Failed to load createHash");
+    }
+    calculateQueryHash = (queryString) => {
+        if (queryString !== lastString) {
+            lastString = queryString;
+            lastHash = createHash("sha1").update(queryString).digest("base64");
+        }
+        return lastHash;
+    };
+}
+catch {
+    calculateQueryHash = (str) => str;
+}
+const parseAndValidate = (gqlSchema, stringOrSource) => {
+    let queryCache = gqlSchema.extensions.grafast?.[interfaces_js_1.$$queryCache];
+    if (!queryCache) {
+        const cacheSize = gqlSchema.extensions.grafast?.queryCacheMaxLength ??
+            defaultQueryCacheMaxSize;
+        queryCache = new lru_1.default({ maxLength: cacheSize });
+        if (!gqlSchema.extensions.grafast) {
+            gqlSchema.extensions.grafast = Object.create(null);
+        }
+        gqlSchema.extensions.grafast[interfaces_js_1.$$queryCache] = queryCache;
+    }
+    // Only cache queries that are less than 100kB, we don't want DOS attacks
+    // attempting to exhaust our memory.
+    const hash = calculateQueryHash(typeof stringOrSource === "string" ? stringOrSource : stringOrSource.body);
+    const result = queryCache.get(hash);
+    if (result !== undefined) {
+        return result;
+    }
+    else {
+        const source = typeof stringOrSource === "string"
+            ? new Source(stringOrSource, "GraphQL Http Request")
+            : stringOrSource;
+        let queryDocumentAst;
+        // Catch an errors while parsing so that we can set the `statusCode` to
+        // 400. Otherwise we don’t need to parse this way.
+        try {
+            queryDocumentAst = parse(source);
+            // Validate our GraphQL query using given rules.
+            const validationErrors = validate(gqlSchema, queryDocumentAst);
+            const cacheResult = validationErrors.length > 0 ? validationErrors : queryDocumentAst;
+            queryCache.set(hash, cacheResult);
+            return cacheResult;
+        }
+        catch (error) {
+            const cacheResult = [
+                error instanceof GraphQLError
+                    ? error
+                    : new GraphQLError("Validation error occurred", undefined, undefined, undefined, undefined, error),
+            ];
+            queryCache.set(hash, cacheResult);
+            return cacheResult;
+        }
+    }
+};
+/**
+ * A replacement for GraphQL.js' `graphql` method that calls Grafast's
+ * execute instead
+ */
+function grafast(args, legacyResolvedPreset, legacyCtx) {
+    const { schema, source, rootValue, contextValue, variableValues, operationName, fieldResolver, typeResolver, resolvedPreset = legacyResolvedPreset, requestContext = legacyCtx, } = args;
+    // Validate Schema
+    const schemaValidationErrors = validateSchema(schema);
+    if (schemaValidationErrors.length > 0) {
+        return { errors: schemaValidationErrors };
+    }
+    // Cached parse and validate
+    const documentOrErrors = parseAndValidate(schema, source);
+    if (Array.isArray(documentOrErrors)) {
+        return { errors: documentOrErrors };
+    }
+    const document = documentOrErrors;
+    const executionArgs = {
+        schema,
+        document,
+        rootValue,
+        contextValue,
+        variableValues,
+        operationName,
+        fieldResolver,
+        typeResolver,
+    };
+    if (resolvedPreset && requestContext) {
+        const argsOrPromise = (0, index_js_1.hookArgs)(executionArgs, resolvedPreset, requestContext);
+        if ((0, utils_js_1.isPromiseLike)(argsOrPromise)) {
+            return Promise.resolve(argsOrPromise).then((hookedArgs) => (0, execute_js_1.execute)(hookedArgs, resolvedPreset));
+        }
+        else {
+            // Execute
+            return (0, execute_js_1.execute)(argsOrPromise, resolvedPreset);
+        }
+    }
+    else {
+        // Execute
+        return (0, execute_js_1.execute)(executionArgs, resolvedPreset);
+    }
+}
+exports.grafast = grafast;
+function grafastSync(args, legacyResolvedPreset, legacyRequestContext) {
+    const result = grafast(args, legacyResolvedPreset, legacyRequestContext);
+    if ((0, utils_js_1.isPromiseLike)(result)) {
+        throw new error_js_1.SafeError("Grafast execution failed to complete synchronously.");
+    }
+    return result;
+}
+exports.grafastSync = grafastSync;
+//# sourceMappingURL=grafastGraphql.js.map