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

package/dist/execute.js

@@ -1,21 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.execute = exports.withGrafastArgs = void 0;
+exports.withGrafastArgs = withGrafastArgs;
+exports.execute = execute;
 const tslib_1 = require("tslib");
 const eventemitter3_1 = tslib_1.__importDefault(require("eventemitter3"));
-const config_js_1 = require("./config.js");
+const dev_js_1 = require("./dev.js");
 const inspect_js_1 = require("./inspect.js");
 const interfaces_js_1 = require("./interfaces.js");
+const middleware_js_1 = require("./middleware.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) {
+function withGrafastArgs(args) {
+    const options = args.resolvedPreset?.grafast;
+    if (dev_js_1.isDev) {
         if (args.rootValue != null &&
             (typeof args.rootValue !== "object" ||
                 Object.keys(args.rootValue).length > 0)) {
@@ -54,8 +55,9 @@ function withGrafastArgs(args, resolvedPreset, outputDataAsString) {
     }
     const rootValue = (0, prepare_js_1.grafastPrepare)(args, {
         explain: options?.explain,
-        outputDataAsString,
         timeouts: options?.timeouts,
+        // TODO: Delete this
+        outputDataAsString: args.outputDataAsString,
     });
     if (unlisten !== null) {
         Promise.resolve(rootValue).then(unlisten, unlisten);
@@ -68,13 +70,27 @@ function withGrafastArgs(args, resolvedPreset, outputDataAsString) {
         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);
+function execute(args, legacyResolvedPreset, legacyOutputDataAsString) {
+    // TODO: remove legacy compatibility
+    if (legacyResolvedPreset !== undefined) {
+        args.resolvedPreset = legacyResolvedPreset;
+    }
+    if (legacyOutputDataAsString !== undefined) {
+        args.outputDataAsString = legacyOutputDataAsString;
+    }
+    const { resolvedPreset } = args;
+    const middleware = args.middleware === undefined && resolvedPreset != null
+        ? (0, middleware_js_1.getGrafastMiddleware)(resolvedPreset)
+        : (args.middleware ?? null);
+    if (args.middleware === undefined) {
+        args.middleware = middleware;
+    }
+    if (middleware !== null) {
+        return middleware.run("execute", { args }, executeMiddlewareCallback);
+    }
+    else {
+        return withGrafastArgs(args);
+    }
 }
-exports.execute = execute;
+const executeMiddlewareCallback = (event) => withGrafastArgs(event.args);
 //# sourceMappingURL=execute.js.map

package/dist/exportAs.d.ts

@@ -1,19 +1,2 @@
-/**
- * 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
- */
-export declare function exportAs<T extends object>(moduleName: string, thing: T, exportName: string | string[]): T;
-/**
- * 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
- */
-export declare function exportAsMany(moduleName: string, all: {
-    [key: string]: any;
-}): void;
+export {};
 //# sourceMappingURL=exportAs.d.ts.map

package/dist/exportAs.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.exportAsMany = exports.exportAs = void 0;
+exports.exportAs = exportAs;
+exports.exportAsMany = exportAsMany;
 const utils_js_1 = require("./utils.js");
 /**
  * Marks that `thing` is exported from the `grafast` module as
@@ -36,7 +37,6 @@ function exportAs(moduleName, thing, exportName) {
     }
     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
@@ -53,5 +53,4 @@ function exportAsMany(moduleName, all) {
         }
     }
 }
-exports.exportAsMany = exportAsMany;
 //# sourceMappingURL=exportAs.js.map

package/dist/global.js

@@ -1,13 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDebug = exports.setDebug = void 0;
+exports.setDebug = setDebug;
+exports.getDebug = getDebug;
 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.d.ts

@@ -5,6 +5,11 @@ import type { GrafastArgs } from "./interfaces.js";
  * A replacement for GraphQL.js' `graphql` method that calls Grafast's
  * execute instead
  */
-export declare function grafast(args: GrafastArgs, legacyResolvedPreset?: GraphileConfig.ResolvedPreset, legacyCtx?: Partial<Grafast.RequestContext>): PromiseOrValue<ExecutionResult | AsyncGenerator<AsyncExecutionResult, void, undefined>>;
+export declare function grafast(args: GrafastArgs): PromiseOrValue<ExecutionResult | AsyncGenerator<AsyncExecutionResult, void, undefined>>;
+/**
+ * @deprecated Second and third parameters should be passed as part of args,
+ * specifically `resolvedPreset` and `requestContext`.
+ */
+export declare function grafast(args: GrafastArgs, legacyResolvedPreset?: GraphileConfig.ResolvedPreset | undefined, legacyCtx?: Partial<Grafast.RequestContext> | undefined): PromiseOrValue<ExecutionResult | AsyncGenerator<AsyncExecutionResult, void, undefined>>;
 export declare function grafastSync(args: GrafastArgs, legacyResolvedPreset?: GraphileConfig.ResolvedPreset, legacyRequestContext?: Partial<Grafast.RequestContext>): ExecutionResult;
 //# sourceMappingURL=grafastGraphql.d.ts.map

package/dist/grafastGraphql.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.grafastSync = exports.grafast = void 0;
+exports.grafast = grafast;
+exports.grafastSync = grafastSync;
 const tslib_1 = require("tslib");
 const lru_1 = tslib_1.__importDefault(require("@graphile/lru"));
 const graphql = tslib_1.__importStar(require("graphql"));
@@ -8,6 +9,7 @@ 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 middleware_js_1 = require("./middleware.js");
 const utils_js_1 = require("./utils.js");
 const { GraphQLError, parse, Source, validate, validateSchema } = graphql;
 /** Rough average size per query */
@@ -79,19 +81,31 @@ const parseAndValidate = (gqlSchema, stringOrSource) => {
         }
     }
 };
-/**
- * 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;
+    // Convert legacy args to properties on `args`:
+    if (legacyResolvedPreset !== undefined) {
+        args.resolvedPreset = args.resolvedPreset ?? legacyResolvedPreset;
+    }
+    if (legacyCtx !== undefined) {
+        args.requestContext = args.requestContext ?? legacyCtx;
+    }
+    const { schema, source, rootValue, contextValue, variableValues, operationName, fieldResolver, typeResolver, resolvedPreset, requestContext, middleware: rawMiddleware, } = args;
+    const middleware = rawMiddleware !== undefined
+        ? rawMiddleware
+        : resolvedPreset != null
+            ? (0, middleware_js_1.getGrafastMiddleware)(resolvedPreset)
+            : null;
     // Validate Schema
-    const schemaValidationErrors = validateSchema(schema);
+    const schemaValidationErrors = middleware != null && resolvedPreset != null
+        ? middleware.runSync("validateSchema", { schema, resolvedPreset }, validateSchemaWithEvent)
+        : validateSchema(schema);
     if (schemaValidationErrors.length > 0) {
         return { errors: schemaValidationErrors };
     }
     // Cached parse and validate
-    const documentOrErrors = parseAndValidate(schema, source);
+    const documentOrErrors = middleware != null && resolvedPreset != null
+        ? middleware.runSync("parseAndValidate", { resolvedPreset, schema, source }, parseAndValidateWithEvent)
+        : parseAndValidate(schema, source);
     if (Array.isArray(documentOrErrors)) {
         return { errors: documentOrErrors };
     }
@@ -105,23 +119,23 @@ function grafast(args, legacyResolvedPreset, legacyCtx) {
         operationName,
         fieldResolver,
         typeResolver,
+        middleware,
+        resolvedPreset,
+        requestContext,
     };
     if (resolvedPreset && requestContext) {
-        const argsOrPromise = (0, index_js_1.hookArgs)(executionArgs, resolvedPreset, requestContext);
+        const argsOrPromise = (0, index_js_1.hookArgs)(executionArgs);
         if ((0, utils_js_1.isPromiseLike)(argsOrPromise)) {
-            return Promise.resolve(argsOrPromise).then((hookedArgs) => (0, execute_js_1.execute)(hookedArgs, resolvedPreset));
+            return Promise.resolve(argsOrPromise).then(execute_js_1.execute);
         }
         else {
-            // Execute
-            return (0, execute_js_1.execute)(argsOrPromise, resolvedPreset);
+            return (0, execute_js_1.execute)(argsOrPromise);
         }
     }
     else {
-        // Execute
-        return (0, execute_js_1.execute)(executionArgs, resolvedPreset);
+        return (0, execute_js_1.execute)(executionArgs);
     }
 }
-exports.grafast = grafast;
 function grafastSync(args, legacyResolvedPreset, legacyRequestContext) {
     const result = grafast(args, legacyResolvedPreset, legacyRequestContext);
     if ((0, utils_js_1.isPromiseLike)(result)) {
@@ -129,5 +143,10 @@ function grafastSync(args, legacyResolvedPreset, legacyRequestContext) {
     }
     return result;
 }
-exports.grafastSync = grafastSync;
+function validateSchemaWithEvent(event) {
+    return validateSchema(event.schema);
+}
+function parseAndValidateWithEvent(event) {
+    return parseAndValidate(event.schema, event.source);
+}
 //# sourceMappingURL=grafastGraphql.js.map

package/dist/grafastPrint.d.ts

@@ -1,4 +1,7 @@
+import type { Bucket } from "./bucket.js";
 export declare function _grafastPrint(symbol: string | symbol | symbol[] | Record<symbol, any> | Map<any, any>, seen: Set<any>): string;
+export declare function recursivePrintBucket(bucket: Bucket, indentLevel?: number): string;
+export declare function printStore(bucket: Bucket): string;
 export declare function grafastColor(text: string, n: number): string;
 /**
  * Prints something grafast-style (i.e. concise, coloured, with helpful detail)

package/dist/grafastPrint.js

@@ -1,8 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ansiPad = exports.grafastPrint = exports.grafastColor = exports._grafastPrint = void 0;
+exports._grafastPrint = _grafastPrint;
+exports.recursivePrintBucket = recursivePrintBucket;
+exports.printStore = printStore;
+exports.grafastColor = grafastColor;
+exports.grafastPrint = grafastPrint;
+exports.ansiPad = ansiPad;
 const tslib_1 = require("tslib");
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const executeBucket_js_1 = require("./engine/executeBucket.js");
+const OutputPlan_js_1 = require("./engine/OutputPlan.js");
 const inspect_js_1 = require("./inspect.js");
 const step_js_1 = require("./step.js");
 const stripAnsi_js_1 = require("./stripAnsi.js");
@@ -48,7 +55,7 @@ function _grafastPrint(symbol, seen) {
     if (symbol === utils_js_1.ROOT_VALUE_OBJECT) {
         return chalk_1.default.gray `(blank)`;
     }
-    if (symbol instanceof step_js_1.ExecutableStep) {
+    if (symbol instanceof step_js_1.Step) {
         return String(symbol);
     }
     if (Array.isArray(symbol)) {
@@ -73,12 +80,18 @@ function _grafastPrint(symbol, seen) {
         }
         return `Map{${pairs.join(", ")}}`;
     }
+    if (isBucket(symbol)) {
+        return recursivePrintBucket(symbol);
+    }
     if (typeof symbol === "object" && symbol) {
         if (symbol instanceof Error) {
             return chalk_1.default.red(`ERROR<${(0, stripAnsi_js_1.stripAnsi)(String(symbol.message))
                 .replace(/\s+/g, " ")
                 .substring(0, 30) + "..."}>`);
         }
+        if (symbol instanceof OutputPlan_js_1.OutputPlan) {
+            return symbol.print();
+        }
         if (![null, Object.prototype, utils_js_1.sharedNull].includes(Object.getPrototypeOf(symbol))) {
             return chalk_1.default.red(`OBJECT<${(0, stripAnsi_js_1.stripAnsi)(String(symbol))}>`);
         }
@@ -95,7 +108,11 @@ function _grafastPrint(symbol, seen) {
     }
     return grafastPrintSymbol(symbol);
 }
-exports._grafastPrint = _grafastPrint;
+function isBucket(thing) {
+    return (typeof thing === "object" &&
+        thing !== null &&
+        thing.toString === executeBucket_js_1.bucketToString);
+}
 function _grafastSymbolDescription(symbol) {
     if (!symbol.description) {
         return chalk_1.default.green("Symbol()");
@@ -109,11 +126,57 @@ function _grafastSymbolDescription(symbol) {
         return chalk_1.default.cyan(`$$${symbol.description}`);
     }
 }
+function indent(level, string) {
+    return " ".repeat(level) + string.replace(/\n/g, `\n${" ".repeat(level)}`);
+}
+function recursivePrintBucket(bucket, indentLevel = 0) {
+    return indent(indentLevel, `Bucket for ${bucket.layerPlan} (size = ${bucket.size}):
+  Store:
+${indent(4, printStore(bucket))}
+  Children:
+${Object.entries(bucket.children)
+        .map(([_id, { bucket }]) => indent(4, recursivePrintBucket(bucket)))
+        .join("\n")}`);
+}
+const PRINT_STORE_INSPECT_OPTIONS = {
+    colors: true,
+    depth: 0,
+    showHidden: false,
+    maxArrayLength: 5,
+    maxStringLength: 50,
+};
+function indentIfMultiline(string) {
+    if (string.includes("\n")) {
+        return indent(4, "\n" + string);
+    }
+    else {
+        return string;
+    }
+}
+function printStore(bucket) {
+    const output = [];
+    for (const [key, val] of bucket.store) {
+        const printKey = String(key).padStart(3, " ");
+        if (bucket.layerPlan.copyStepIds.includes(key)) {
+            output.push(`${printKey} (copy)`);
+        }
+        else if (val.isBatch) {
+            const step = bucket.layerPlan.operationPlan.stepTracker.getStepById(key, true);
+            output.push(`${printKey} (BATCH): ${step ?? "-"}\n${indent(2, val.entries
+                .map((e, i) => `${String(i).padStart(3, " ")}: flags=${String(val._flagsAt(i)).padStart(2, " ")} value=${indentIfMultiline((0, inspect_js_1.inspect)(val.at(i), PRINT_STORE_INSPECT_OPTIONS))}`)
+                .join("\n"))}`);
+        }
+        else {
+            const step = bucket.layerPlan.operationPlan.stepTracker.getStepById(key, true);
+            output.push(`${printKey} (UNARY/${String(val._entryFlags).padStart(2, " ")}) ${step ?? "-"}\n${indent(4, (0, inspect_js_1.inspect)(val.value, PRINT_STORE_INSPECT_OPTIONS))}`);
+        }
+    }
+    return output.join("\n") || "EMPTY";
+}
 function grafastColor(text, n) {
     const color = COLORS[Math.abs(n) % COLORS.length];
     return color(text);
 }
-exports.grafastColor = grafastColor;
 const symbolsByAlias = new Map();
 let symbolClear = null;
 /**
@@ -151,7 +214,6 @@ function grafastPrintSymbol(symbol) {
 function grafastPrint(symbol) {
     return _grafastPrint(symbol, new Set());
 }
-exports.grafastPrint = grafastPrint;
 /**
  * An ANSI-aware pad function; strips ANSI sequences from the string, figures
  * out how much it needs to pad it by, and then pads the original string by
@@ -173,5 +235,4 @@ function ansiPad(ansiString, targetLength, fill, position) {
         return ansiString;
     }
 }
-exports.ansiPad = ansiPad;
 //# sourceMappingURL=grafastPrint.js.map

package/dist/graphqlCollectFields.d.ts

@@ -1,37 +1,10 @@
-import type { DirectiveNode, FieldNode, SelectionNode } from "graphql";
-import * as graphql from "graphql";
-import type { OperationPlan } from "./engine/OperationPlan.js";
+import type { DirectiveNode } from "graphql";
 import type { __TrackedValueStep } from "./steps/index.js";
-/**
- * Given a selection, finds the first directive named `directiveName` and, if
- * found, extracts and returns the value from the argument named
- * `argumentName`, tracking variable access if necessary.
- *
- * @remarks Currently only supports booleans.
- *
- * @internal
- *
- * PERF: inline.
- */
-export declare function evalDirectiveArg<T = unknown>(selection: SelectionNode, directiveName: string, argumentName: string, variableValuesStep: __TrackedValueStep, defaultValue: T): T | undefined;
 export declare function evalDirectiveArgDirect<T = unknown>(directive: DirectiveNode, argumentName: string, variableValuesStep: __TrackedValueStep, defaultValue: T): T | undefined;
-/**
- * @internal
- */
-export interface SelectionSetDigest {
-    label: string | undefined;
-    fields: Map<string, FieldNode[]>;
-    deferred: SelectionSetDigest[] | undefined;
-}
-/**
- * Implements the `GraphQLCollectFields` algorithm - like `CollectFields` the
- * GraphQL spec, but modified such that access to variables is tracked.
- *
- * @see https://spec.graphql.org/draft/#CollectFields()
- *
- * @internal
- */
-export declare function graphqlCollectFields(operationPlan: OperationPlan, parentStepId: number, objectType: graphql.GraphQLObjectType, selections: readonly SelectionNode[], isMutation?: boolean, visitedFragments?: {
-    [fragmentName: string]: true;
-}, selectionSetDigest?: SelectionSetDigest): SelectionSetDigest;
+export declare function newSelectionSetDigest(resolverEmulation: boolean): {
+    label: undefined;
+    fields: Map<any, any>;
+    deferred: undefined;
+    resolverEmulation: boolean;
+};
 //# sourceMappingURL=graphqlCollectFields.d.ts.map

package/dist/graphqlCollectFields.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.graphqlCollectFields = exports.evalDirectiveArgDirect = exports.evalDirectiveArg = void 0;
+exports.evalDirectiveArg = evalDirectiveArg;
+exports.evalDirectiveArgDirect = evalDirectiveArgDirect;
+exports.newSelectionSetDigest = newSelectionSetDigest;
+exports.graphqlCollectFields = graphqlCollectFields;
 const tslib_1 = require("tslib");
 const graphql = tslib_1.__importStar(require("graphql"));
 const error_js_1 = require("./error.js");
@@ -32,7 +35,6 @@ function evalDirectiveArg(selection, directiveName, argumentName, variableValues
         return undefined;
     return evalDirectiveArgDirect(directive, argumentName, variableValuesStep, defaultValue);
 }
-exports.evalDirectiveArg = evalDirectiveArg;
 function evalDirectiveArgDirect(directive, argumentName, variableValuesStep, defaultValue) {
     if (!directive.arguments)
         return defaultValue;
@@ -49,6 +51,12 @@ function evalDirectiveArgDirect(directive, argumentName, variableValuesStep, def
             case "IntValue": {
                 return parseInt(value.value, 10);
             }
+            case "FloatValue": {
+                return parseFloat(value.value);
+            }
+            case "StringValue": {
+                return value.value;
+            }
             case "NullValue": {
                 return null;
             }
@@ -61,7 +69,6 @@ function evalDirectiveArgDirect(directive, argumentName, variableValuesStep, def
         return defaultValue;
     }
 }
-exports.evalDirectiveArgDirect = evalDirectiveArgDirect;
 /**
  * Implements the `DoesFragmentTypeApply` algorithm from the GraphQL
  * specification.
@@ -90,16 +97,17 @@ const processFragment = (operationPlan, parentStepId, objectType, isMutation, se
     const trackedVariableValuesStep = operationPlan.trackedVariableValuesStep;
     const defer = selection.directives?.find((d) => d.name.value === "defer");
     const deferIf = defer
-        ? evalDirectiveArgDirect(defer, "if", trackedVariableValuesStep, true) ?? true
+        ? (evalDirectiveArgDirect(defer, "if", trackedVariableValuesStep, true) ?? true)
         : undefined;
     const label = defer
-        ? evalDirectiveArgDirect(defer, "label", trackedVariableValuesStep, null) ?? undefined
+        ? (evalDirectiveArgDirect(defer, "label", trackedVariableValuesStep, null) ?? undefined)
         : undefined;
     const deferredDigest = deferIf === true
         ? {
             label,
             fields: new Map(),
             deferred: undefined,
+            resolverEmulation: selectionSetDigest.resolverEmulation,
         }
         : null;
     if (deferredDigest !== null) {
@@ -110,8 +118,16 @@ const processFragment = (operationPlan, parentStepId, objectType, isMutation, se
             selectionSetDigest.deferred.push(deferredDigest);
         }
     }
-    graphqlCollectFields(operationPlan, parentStepId, objectType, fragmentSelectionSet.selections, isMutation, visitedFragments, deferredDigest ?? selectionSetDigest);
+    graphqlCollectFields(operationPlan, parentStepId, objectType, fragmentSelectionSet.selections, deferredDigest ?? selectionSetDigest, isMutation, visitedFragments);
 };
+function newSelectionSetDigest(resolverEmulation) {
+    return {
+        label: undefined,
+        fields: new Map(),
+        deferred: undefined,
+        resolverEmulation,
+    };
+}
 /**
  * Implements the `GraphQLCollectFields` algorithm - like `CollectFields` the
  * GraphQL spec, but modified such that access to variables is tracked.
@@ -120,13 +136,9 @@ const processFragment = (operationPlan, parentStepId, objectType, isMutation, se
  *
  * @internal
  */
-function graphqlCollectFields(operationPlan, parentStepId, objectType, selections, isMutation = false, 
+function graphqlCollectFields(operationPlan, parentStepId, objectType, selections, selectionSetDigest, isMutation = false, 
 // This is significantly faster than an array or a Set
-visitedFragments = Object.create(null), selectionSetDigest = {
-    label: undefined,
-    fields: new Map(),
-    deferred: undefined,
-}) {
+visitedFragments = Object.create(null)) {
     // const objectTypeFields = objectType.getFields();
     const trackedVariableValuesStep = operationPlan.trackedVariableValuesStep;
     for (let i = 0, l = selections.length; i < l; i++) {
@@ -213,5 +225,4 @@ visitedFragments = Object.create(null), selectionSetDigest = {
     }
     return selectionSetDigest;
 }
-exports.graphqlCollectFields = graphqlCollectFields;
 //# sourceMappingURL=graphqlCollectFields.js.map

package/dist/graphqlMergeSelectionSets.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fieldSelectionsForType = void 0;
+exports.fieldSelectionsForType = fieldSelectionsForType;
 const tslib_1 = require("tslib");
 const graphql = tslib_1.__importStar(require("graphql"));
 const inspect_js_1 = require("./inspect.js");
@@ -56,5 +56,4 @@ function fieldSelectionsForType(operationPlan, type, selections, result = []) {
     }
     return result;
 }
-exports.fieldSelectionsForType = fieldSelectionsForType;
 //# sourceMappingURL=graphqlMergeSelectionSets.js.map