grafast 0.0.1-alpha.9 → 0.0.1-beta.2

package/dist/engine/OperationPlan.d.ts

@@ -11,6 +11,7 @@ import { OutputPlan } from "./OutputPlan.js";
 import { StepTracker } from "./StepTracker.js";
 export declare const POLYMORPHIC_ROOT_PATH: null;
 export declare const POLYMORPHIC_ROOT_PATHS: ReadonlySet<string> | null;
+/** @internal */
 export type OperationPlanPhase = "init" | "plan" | "validate" | "optimize" | "finalize" | "ready";
 export interface MetaByMetaKey {
     [metaKey: string | number | symbol]: Record<string, any>;
@@ -38,35 +39,76 @@ export declare class OperationPlan {
         [objectTypeName: string]: ReadonlyArray<GraphQLUnionType>;
     };
     private operationType;
+    /**
+     * What state is the OpPlan in?
+     *
+     * 1. init
+     * 2. plan
+     * 3. validate
+     * 5. optimize
+     * 6. finalize
+     * 7. ready
+     *
+     * Once in 'ready' state we can execute the plan.
+     *
+     * @internal
+     */
     phase: OperationPlanPhase;
+    /**
+     * Gets updated as we work our way through the plan, useful for making errors more helpful.
+     */
     loc: string[] | null;
+    /** @internal */
     rootLayerPlan: LayerPlan;
+    /**
+     * Assigned during OperationPlan.planOperation(), guaranteed to exist after
+     * initialization.
+     *
+     * @internal
+     */
     rootOutputPlan: OutputPlan;
     private modifierStepCount;
     private modifierDepthCount;
     private modifierSteps;
+    /** @internal */
     readonly stepTracker: StepTracker;
     private maxDeduplicatedStepId;
     private maxValidatedStepId;
+    /** Constraints based on evaluating variables. @internal */
     readonly variableValuesConstraints: Constraint[];
+    /** Stores the actual variableValues. @internal */
     readonly variableValuesStep: __ValueStep<{
         [key: string]: any;
     }>;
+    /** A step for accessing variableValues in a tracked manner (allowing eval). @internal */
     readonly trackedVariableValuesStep: __TrackedValueStep<{
         [key: string]: any;
     }>;
+    /** Constraints based on evaluating context. @internal */
     readonly contextConstraints: Constraint[];
+    /** Stores the actual value of the context. @internal */
     readonly contextStep: __ValueStep<Grafast.Context>;
+    /** Allows accessing context in a tracked manner (allowing eval). @internal */
     readonly trackedContextStep: __TrackedValueStep<{
         [key: string]: any;
     }>;
+    /** Constraints based on evaluating rootValue. @internal */
     readonly rootValueConstraints: Constraint[];
+    /** Stores the actual value of rootValue. @internal */
     readonly rootValueStep: __ValueStep<any>;
+    /** Allows accessing rootValue in a tracked manner (allowing eval). @internal */
     readonly trackedRootValueStep: __TrackedValueStep<any>;
+    /** @internal */
     makeMetaByMetaKey: () => MetaByMetaKey;
+    /**
+     * @internal
+     */
     readonly itemStepIdByListStepId: {
         [listStepId: number]: number | undefined;
     };
+    /**
+     * If true, then this operation doesn't use (custom) resolvers.
+     */
     pure: boolean;
     private startTime;
     private previousLap;
@@ -82,50 +124,159 @@ export declare class OperationPlan {
     }, rootValue: any, planningTimeout: number | null);
     private lap;
     private checkTimeout;
+    /**
+     * Called by the LayerPlan's constructor when it wants to get a new id to use.
+     *
+     * @internal
+     */
     addLayerPlan(layerPlan: LayerPlan): number;
+    /**
+     * Adds a plan to the known steps and returns the number to use as the plan
+     * id. ONLY to be used from Step, user code should never call this directly.
+     *
+     * @internal
+     */
     _addStep(plan: ExecutableStep): number;
+    /**
+     * Adds a plan to the known steps and returns the number to use as the plan
+     * id. ONLY to be used from Step, user code should never call this directly.
+     *
+     * @internal
+     */
     _addModifierStep(step: ModifierStep<any>): string;
+    /** @internal Use plan.getStep(id) instead. */
     getStep: (id: number, requestingStep: ExecutableStep) => ExecutableStep;
+    /**
+     * Get a plan without specifying who requested it; this disables all the
+     * caller checks. Only intended to be called from internal code.
+     *
+     * @internal
+     */
     dangerouslyGetStep(id: number): ExecutableStep;
     private planOperation;
+    /**
+     * Plans a GraphQL query operation.
+     */
     private planQuery;
+    /**
+     * Implements the `PlanOpPlanMutation` algorithm.
+     */
     private planMutation;
+    /**
+     * Implements the `PlanOpPlanSubscription` algorithm.
+     */
     private planSubscription;
+    /**
+     * Gets the item plan for a given parent list plan - this ensures we only
+     * create one item plan per parent plan.
+     */
     private itemStepForListStep;
     processGroupedFieldSet(outputPlan: OutputPlan, path: readonly string[], polymorphicPath: string | null, polymorphicPaths: ReadonlySet<string> | null, parentStep: ExecutableStep, objectType: GraphQLObjectType, objectTypeFields: GraphQLFieldMap<any, any>, isMutation: boolean, groupedFieldSet: SelectionSetDigest): void;
+    /**
+     *
+     * @param outputPlan - The output plan that this selection set is being added to
+     * @param path - The path within the outputPlan that we're adding stuff (only for root/object OutputPlans)
+     * @param parentStep - The step that represents the selection set root
+     * @param objectType - The object type that this selection set is being evaluated for (note polymorphic selection should already have been handled by this point)
+     * @param selections - The GraphQL selections (fields, fragment spreads, inline fragments) to evaluate
+     * @param isMutation - If true this selection set should be executed serially rather than in parallel (each field gets its own LayerPlan)
+     */
     private planSelectionSet;
     private planIntoOutputPlan;
     private polymorphicLayerPlanByPathByLayerPlan;
     private getPolymorphicLayerPlan;
     private planField;
+    /**
+     * A replacement for GraphQL's
+     * `CoerceArgumentValues` that factors in tracked variables.
+     *
+     * @see https://spec.graphql.org/draft/#CoerceArgumentValues()
+     */
     private getTrackedArguments;
     withModifiers<T>(cb: () => T): T;
+    /**
+     * Sets up tracking for the given value (variableValues, context, rootValue).
+     */
     private track;
+    /**
+     * Checks that no step has a property on it whose value is another step. It
+     * should addDependency instead.
+     */
     private validateSteps;
     private replaceStep;
     private processStep;
+    /**
+     * Process the given steps, either dependencies first (root to leaf) or
+     * dependents first (leaves to root).
+     *
+     * @internal
+     */
     processSteps(actionDescription: string, order: "dependents-first" | "dependencies-first", isReadonly: boolean, callback: (plan: ExecutableStep) => ExecutableStep): void;
+    /**
+     * Peers are steps of the same type (but not the same step!) that are in
+     * compatible layers and have the same dependencies. Peers must not have side
+     * effects. A step is not its own peer.
+     */
     private getPeers;
     private isImmoveable;
+    /**
+     * Attempts to hoist the step into a higher layerPlan to maximize
+     * deduplication.
+     */
     private hoistStep;
+    /**
+     * Attempts to push the step into the lowest layerPlan to minimize the need
+     * for copying between layer plans.
+     */
     private pushDown;
     private _deduplicateInnerLogic;
     private deduplicateStep;
     private deduplicateStepsProcess;
+    /**
+     * Gives us a chance to replace nearly-duplicate plans with other existing
+     * plans (and adding the necessary transforms); this means that by the time
+     * we come to optimize the plan tree should already be simpler. For example
+     * if you have two plans at the same level that both request row data from
+     * the same database table with the same identifiers, `WHERE`, `LIMIT`,
+     * `OFFSET` and `ORDER BY`, but different `SELECT`s we could merge the two
+     * plans together by replacing the latter with the former and having the
+     * former SELECT additional fields, then transform the results back to what
+     * our child plans would be expecting.
+     */
     private deduplicateSteps;
     private hoistAndDeduplicate;
     private hoistSteps;
     private pushDownSteps;
     private getStepOptionsForStep;
+    /**
+     * Calls the 'optimize' method on a plan, which may cause the plan to
+     * communicate with its (deep) dependencies, and even to replace itself with
+     * a different plan.
+     */
     private optimizeStep;
+    /**
+     * Note that we work through dependents first so we can make sure that we
+     * know all our dependent's needs before we optimise ourself.
+     */
     private optimizeSteps;
+    /** Finalizes each step */
     private finalizeSteps;
     private finalizeLayerPlans;
+    /** Optimizes each output plan */
     private optimizeOutputPlans;
+    /** Finalizes each output plan */
     private finalizeOutputPlans;
     private walkOutputPlans;
+    /**
+     * Convert an OpPlan into a plan graph in mermaid-js format.
+     */
     printPlanGraph(options?: PrintPlanGraphOptions): string;
     finishSubroutine(subroutineStep: ExecutableStep, layerPlan: LayerPlan<LayerPlanReasonSubroutine>): void;
+    /**
+     * HIGHLY EXPERIMENTAL!
+     *
+     * @internal
+     */
     deleteLayerPlan(layerPlan: LayerPlan): void;
     getStepsByMetaKey(metaKey: string | number | symbol): ExecutableStep[];
     getStepsByStepClass<TClass extends ExecutableStep>(klass: {

package/dist/engine/OutputPlan.d.ts

@@ -8,34 +8,80 @@ import type { PayloadRoot } from "./executeOutputPlan.js";
 import type { LayerPlan } from "./LayerPlan.js";
 export type OutputPlanTypeIntrospection = {
     mode: "introspection";
+    /**
+     * The GraphQL introspection field selection (may include arguments/etc). We
+     * can build a GraphQL document from this and issue it to graphql-js rather
+     * than replicating that effort.
+     */
     field: FieldNode;
+    /**
+     * The names of the variables used in this document.
+     */
     variableNames: string[];
+    /**
+     * No need to re-run the introspection each time, may as well cache it,
+     * right?
+     *
+     * Key: canonical JSON stringify of the variables used.
+     * Value: the GraphQL result (`{data, errors}`) for this.
+     */
     introspectionCacheByVariableValues: LRU<string, JSONValue>;
 };
 export type OutputPlanTypeRoot = {
+    /**
+     * Always return `{}`
+     */
     mode: "root";
     typeName: string;
 };
 export type OutputPlanTypeObject = {
+    /**
+     * Return `{}` if non-null
+     */
     mode: "object";
     typeName: string;
     deferLabel: string | undefined;
 };
 export type OutputPlanTypePolymorphicObject = {
+    /**
+     * Return `{}` if non-null
+     */
     mode: "polymorphic";
     typeNames: string[];
     deferLabel: string | undefined;
 };
 export type OutputPlanTypeArray = {
+    /**
+     * Return a list of the same length if an array
+     */
     mode: "array";
 };
 export type OutputPlanTypeLeaf = {
+    /**
+     * Return the value.
+     */
     mode: "leaf";
     graphqlType: GraphQLScalarType | GraphQLEnumType;
 };
 export type OutputPlanTypeNull = {
     mode: "null";
 };
+/**
+ * Thanks to `@stream`, output plans must handle their own nullability concerns
+ * and we might need an output plan for any of these:
+ *
+ * - A concrete object
+ * - A polymorphic object
+ * - A leaf (enum/scalar)
+ * - Something we know will always be null
+ * - A list of any of the above
+ * - A list of lists
+ *
+ * In addition to the above, we also need to cover
+ *
+ * - The root object (which is like a concrete object, except it's never null)
+ * - Introspection
+ */
 export type OutputPlanType = OutputPlanTypeRoot | OutputPlanTypeObject | OutputPlanTypePolymorphicObject | OutputPlanTypeLeaf | OutputPlanTypeNull | OutputPlanTypeArray | OutputPlanTypeIntrospection;
 export type OutputPlanKeyValueOutputPlan = {
     type: "outputPlan";
@@ -51,22 +97,69 @@ export type OutputPlanKeyValue = OutputPlanKeyValueOutputPlan | OutputPlanKeyVal
 export type OutputPlanKeyValueOutputPlanWithCachedBits = OutputPlanKeyValueOutputPlan & {
     layerPlanId: number;
 };
+/**
+ * Defines a way of taking a layerPlan and converting it into an output value.
+ *
+ * The result of executing an output plan will be the following:
+ *
+ * - data?: the data for this layer, could be object, array or leaf (see OutputPlanMode)
+ * - errors: a list of errors that occurred (if any), including path details _within the output plan_
+ * - streams: a list of streams that were created
+ */
 export declare class OutputPlan<TType extends OutputPlanType = OutputPlanType> {
     layerPlan: LayerPlan;
     readonly type: TType;
+    /** For errors */
     readonly locationDetails: LocationDetails;
+    /**
+     * The step that represents the root value. How this is used depends on the
+     * OutputPlanMode.
+     */
     readonly rootStep: ExecutableStep;
+    /**
+     * Appended to the root step when accessed to avoid the need for AccessSteps
+     */
     private processRoot;
+    /**
+     * For root/object output plans, the keys to set on the resulting object
+     * grouped by the concrete object type name.
+     *
+     * IMPORTANT: the order of these keys is significant, they MUST match the
+     * order in the request otherwise we break GraphQL spec compliance!
+     */
     keys: {
         [key: string]: OutputPlanKeyValueTypeName | OutputPlanKeyValueOutputPlanWithCachedBits;
     };
+    /**
+     * For list output plans, the output plan that describes the list children.
+     */
     child: OutputPlan | null;
     childIsNonNull: boolean;
+    /**
+     * For polymorphic output plans, the Object output plan for each specific type.
+     */
     childByTypeName: {
         [typeName: string]: OutputPlan<OutputPlanTypeObject>;
     } | undefined;
+    /**
+     * For object output plan types only.
+     */
     deferredOutputPlans: OutputPlan<OutputPlanTypeObject | OutputPlanTypePolymorphicObject>[];
-    constructor(layerPlan: LayerPlan, rootStep: ExecutableStep, type: TType, locationDetails: LocationDetails);
+    constructor(layerPlan: LayerPlan, 
+    /**
+     * For root, this should always be an object.
+     *
+     * For object this could represent an object or null.
+     *
+     * For polymorphic this could represent a polymorphic object or null.
+     *
+     * For array it's the list itself (or null) and dictates the length of the result.
+     *
+     * For leaf, it's the leaf plan itself.
+     *
+     * For `introspection`, `null` it's irrelevant. Use `constant(null)` or whatever.
+     */
+    rootStep: ExecutableStep, type: TType, locationDetails: LocationDetails);
     print(): string;
     toString(): string;
     addChild(type: GraphQLObjectType | null, key: string | null, child: OutputPlanKeyValue): void;
@@ -79,5 +172,16 @@ export declare class OutputPlan<TType extends OutputPlanType = OutputPlanType> {
 }
 export declare function coerceError(error: Error, locationDetails: LocationDetails, path: ReadonlyArray<string | number>): graphql.GraphQLError;
 export declare function nonNullError(locationDetails: LocationDetails, path: readonly (string | number)[]): graphql.GraphQLError;
+/**
+ * We're currently running OutputPlan `outputPlan` in bucket `bucket` at index
+ * `bucketIndex`. If this is an array OutputPlan then we're looping over the
+ * entries in our list and we're currently at index `inArrayIndex` (otherwise
+ * this is null).
+ *
+ * Now we want to run `childOutputPlan`, but to do so we need to find the
+ * related `childBucket` and `childBucketIndex`.
+ *
+ * @internal
+ */
 export declare function getChildBucketAndIndex(childOutputPlan: OutputPlan, outputPlan: OutputPlan | null, bucket: Bucket, bucketIndex: number, arrayIndex?: number | null): [Bucket, number] | null;
 //# sourceMappingURL=OutputPlan.d.ts.map

package/dist/engine/StepTracker.d.ts

@@ -2,37 +2,92 @@ import type { OperationPlan } from "../index.js";
 import type { ExecutableStep } from "../step";
 import type { LayerPlan, LayerPlanReasonsWithParentStep } from "./LayerPlan";
 import type { OutputPlan } from "./OutputPlan";
+/**
+ * This class keeps track of all of our steps, and the dependencies between
+ * steps and other steps, layer plans and steps, and output plans and steps.
+ *
+ * When a step is replaced by another step, all the dependencies are updated
+ * such that the replaced step simply evaporates.
+ *
+ * @internal
+ */
 export declare class StepTracker {
     private readonly operationPlan;
+    /** @internal */
     stepCount: number;
+    /** @internal */
     activeSteps: Set<ExecutableStep<any>>;
+    /** @internal */
     stepById: {
         [stepId: number]: ExecutableStep | null;
     };
+    /** @internal */
     private aliasesById;
+    /** @internal */
     stepsWithNoDependencies: Set<ExecutableStep<any>>;
+    /** @internal */
     outputPlansByRootStep: Map<ExecutableStep<any>, Set<OutputPlan<import("./OutputPlan").OutputPlanType>>>;
+    /** @internal */
     layerPlansByRootStep: Map<ExecutableStep<any>, Set<LayerPlan<import("./LayerPlan").LayerPlanReason>>>;
+    /** @internal */
     layerPlansByParentStep: Map<ExecutableStep<any>, Set<LayerPlan<LayerPlanReasonsWithParentStep>>>;
+    /** @internal */
     layerPlans: Array<LayerPlan | null>;
+    /**
+     * All the OutputPlans that were created to allow a more efficient
+     * walkOutputPlans implementation.
+     *
+     * @internal
+     */
     allOutputPlans: OutputPlan[];
     nextStepIdToDeduplicate: number;
     constructor(operationPlan: OperationPlan);
     newStepsSince(oldStepCount: number): ExecutableStep<any>[];
-    finalize(): void;
+    private forbid;
+    /** Called when OperationPlan enters finalize phase. */
+    finalizeSteps(): void;
+    /** Called when OperationPlan is about to finalize the output plans. */
+    finalizeOutputPlans(): void;
     addStep($step: ExecutableStep): number;
+    /**
+     * @internal
+     */
     addLayerPlan(layerPlan: LayerPlan): number;
+    /**
+     * @internal
+     */
     addOutputPlan(outputPlan: OutputPlan): void;
+    /**
+     * HIGHLY EXPERIMENTAL!
+     *
+     * @internal
+     */
     deleteLayerPlan(layerPlan: LayerPlan): void;
     getStepById(id: number): ExecutableStep;
     getStepById(id: number, allowUnset: true): ExecutableStep | null;
     addStepDependency($dependent: ExecutableStep, $dependency: ExecutableStep): number;
     setOutputPlanRootStep(outputPlan: OutputPlan, $dependency: ExecutableStep): void;
     setLayerPlanRootStep(layerPlan: LayerPlan, $dependency: ExecutableStep): void;
+    /** @internal */
     replaceStep($original: ExecutableStep, $replacement: ExecutableStep): void;
     treeShakeSteps(): void;
+    /**
+     * Return true if this step can be tree-shaken.
+     */
     private isNotNeeded;
+    /**
+     * Only for use during planField.
+     */
     purgeBackTo(count: number): void;
+    /**
+     * ONLY CALL THIS IF NOTHING DEPENDS ON $original! It's intended to be called
+     * from `replaceStep` or from itself.
+     *
+     * This method removes $original from the various maps/sets/lists, and also
+     * removes the fact that it was dependent on other steps. If these other
+     * steps no longer have any dependents (steps, layer plans or output plans)
+     * then they can also be eradicated _except_ during the 'plan' phase.
+     */
     private eradicate;
     moveStepToLayerPlan(step: ExecutableStep, targetLayerPlan: LayerPlan): void;
     addStepToItsLayerPlan(step: ExecutableStep): void;

package/dist/engine/executeBucket.d.ts

@@ -1,5 +1,8 @@
 import type { Bucket, RequestTools } from "../bucket.js";
 import type { PromiseOrDirect } from "../interfaces.js";
+import type { MetaByMetaKey } from "./OperationPlan.js";
+/** @internal */
 export declare function executeBucket(bucket: Bucket, requestContext: RequestTools): PromiseOrDirect<void>;
-export declare function newBucket(spec: Pick<Bucket, "layerPlan" | "store" | "size" | "hasErrors" | "polymorphicPathList">): Bucket;
+/** @internal */
+export declare function newBucket(spec: Pick<Bucket, "layerPlan" | "store" | "size" | "hasErrors" | "polymorphicPathList" | "iterators">, parentMetaByMetaKey: MetaByMetaKey | null): Bucket;
 //# sourceMappingURL=executeBucket.d.ts.map

package/dist/engine/executeOutputPlan.d.ts

@@ -6,11 +6,49 @@ export type OutputPath = Array<string | number>;
 export interface OutputStream {
     asyncIterable: AsyncIterableIterator<any>;
 }
+/**
+ * PayloadRoot handles the root-level of a payload, it's ultimately responsible
+ * for sharing the `data`/`errors` with the user. But it also handles the
+ * intermediate payloads for stream/defer.
+ *
+ * A standard GraphQL query/mutation request (one that doesn't use
+ * `@stream`/`@defer`) will have just one payload. A standard GraphQL
+ * subscription request gets one payload per subscription event.
+ *
+ * When we mix `@stream` and `@defer` into this, we will require (often quite a
+ * lot) more payloads.
+ *
+ * @internal
+ */
 export interface PayloadRoot {
+    /**
+     * Serialization works differently if we're running inside GraphQL. (Namely:
+     * we don't serialize - that's GraphQL's job.)
+     */
     insideGraphQL: false;
+    /**
+     * The errors that have occurred; these are proper GraphQLErrors and will be
+     * returned directly to clients so they must be complete.
+     */
     errors: GraphQLError[];
+    /**
+     * Defer queue - we don't start executing these until after the main
+     * payload is completed (to allow for a non-null boundary to abort
+     * execution).
+     */
     queue: Array<SubsequentPayloadSpec>;
+    /**
+     * Stream queue - we don't start executing these until after the main
+     * payload is completed (to allow for a non-null boundary to abort
+     * execution).
+     */
     streams: Array<SubsequentStreamSpec>;
+    /**
+     * VERY DANGEROUS. This is _only_ to pass variables through to introspection
+     * selections, it shouldn't be used for anything else.
+     *
+     * @internal
+     * */
     variables: {
         [key: string]: any;
     };
@@ -35,8 +73,11 @@ export interface SubsequentStreamSpec {
     bucketIndex: number;
     outputPlan: OutputPlan;
     label: string | undefined;
-    stream: AsyncIterableIterator<any>;
+    stream: AsyncIterator<any> | Iterator<any>;
     startIndex: number;
 }
+/**
+ * @internal
+ */
 export declare function executeOutputPlan(ctx: OutputPlanContext, outputPlan: OutputPlan, bucket: Bucket, bucketIndex: number, outputDataAsString: boolean): JSONValue;
 //# sourceMappingURL=executeOutputPlan.d.ts.map

package/dist/envelop.d.ts

@@ -1,7 +1,19 @@
 import type { Plugin as EnvelopPlugin } from "@envelop/core";
 export interface UseGrafastOptions {
+    /**
+     * Set this to 'true' to allow all explains; set it to a list of the allowed
+     * explains to allow only those, set it to false to disable explains.
+     */
     explainAllowed?: boolean | string[];
 }
+/**
+ * An Envelop plugin that uses Grafast to prepare and execute the GraphQL
+ * query.
+ */
 export declare const useGrafast: (options?: UseGrafastOptions) => EnvelopPlugin;
+/**
+ * An Envelop plugin that will make any GraphQL errors easier to read from
+ * inside of GraphiQL.
+ */
 export declare const useMoreDetailedErrors: () => EnvelopPlugin;
 //# sourceMappingURL=envelop.d.ts.map

package/dist/envelop.js

@@ -1,54 +1,5 @@
-const { Buffer } = require('node:buffer');
-const { scryptSync, createDecipheriv } = require('node:crypto');
-const pkgName = "grafast";
-const pkgVersion = "0.0.1-alpha.9";
-
-const RESET = '\x1b[0m';
-const BOLD_BLACK_ON_RED = '\x1b[40;31;1;7m';
-const RED = '\x1b[31m';
-const BOLD = '\x1b[1m';
-const BOLD_BLUE = '\x1b[34;1m';
-const BOLD_BLUE_UNDERLINED = '\x1b[34;1;4m';
-
-const iSponsorGraphile = `${RESET}${BOLD_BLUE}I_SPONSOR_GRAPHILE${RESET}${RED}`;
-const website = `${RESET}${BOLD_BLUE_UNDERLINED}https://grafast.org${RESET}`;
-const errorPrefix = `${BOLD_BLACK_ON_RED}[  ERROR  ]${RESET} ${RED}`;
-const errorSuffix = `${RESET}
-${BOLD_BLACK_ON_RED}[ CONTEXT ]${RESET} ${RED}You are attempting to run pre-release software that is only available to Graphile sponsors.${RESET}
-
-Please refer to the ${website} documentation for the right code to use with this version '${BOLD}${pkgName}@${pkgVersion}${RESET}'.${RESET}
-`;
-
-const password = process.env.I_SPONSOR_GRAPHILE;
-if (typeof password !== 'string') {
-  console.error(
-    `${errorPrefix}You must set the ${iSponsorGraphile} environmental variable to the shared secret to use this pre-release software.${errorSuffix}`,
-  );
-  process.exit(42);
-}
-
-const algorithm = "aes-192-cbc";
-const salt = "We wouldn't be able to do so much OSS without sponsorship. 8585103646644423";
-const key = scryptSync(password, salt, 24);
-const ivBuffer = Buffer.from("iqQBrlQhhzLygmT7ks2rJQ==", "base64");
-const iv = new Uint8Array(ivBuffer.buffer, ivBuffer.byteOffset, ivBuffer.length);
-const decipher = createDecipheriv(algorithm, key, iv);
-const encrypted = "AmT/IOgDt1FGoVOYzAKMlZupq/MPvSJrqBAW/mdLvRna1yQ6KzmfFYwF9hObAuhFTPr5QH8bQEvB1MLD7WBfCLpYAR6Txzi5DIuIAnHNMpFIR6Umv7heJsn4w/UmO38gKoXsDvJgAhBARl1DiKDa8lPOQntQVZbFSGKjIZ9gzhnbx8ACpFGKci/1kgmNxuko76gTdEWrvLV5Bdhbbx8JG5qpwluJC1ya4AExLxwThsgLUaAu5s91hjLiW74Wd+0qxoL1EvO5kHrGZyCtbut0CWtzSm9X+tOjM5qLG2xXTgzEzX8JEspbr82i6jorHy9S7yRtd3jfKx/2OnKxDAZ1RLu1EP459599sLSzZZJt0wcgrVxokMHRdwtXtbPVAWIoehfjI12djGxkTKgPn6n1JlGD5CRLvuush6maBuKZkibiZvgvVyvcVcNAAXxGc2T2owlKf/QPWa4MI+/KH7OWT/qEeMLdgjwCoQVEFeXMxIhjEWeJU1omvZbrgUkWrq2oG3VsPcSm+wjjdxxekHNYy3UP6m+iM012jtUkZBWv1aqEWSroklOyiXMwWl8YSrt9Q35ZUlvh7pv3g4Xyqf6MBj5+RnHfIv/mDIhmwpe3zDSQVqB3okVdtCWNhTeQX/dU40NoYMDkNahRxF23IcCkYUdHbKDjiqKFymsr7E5+PX97ffpehPW2lgjR6CQcjZfQyfy0tHI4FkU3SjHwMYKPq1RRQ6w69sCyrhZHph84fKY+CuXTd36JzuN8wRYe5sGUk6r7rZ2Cs8q3gDJp5sw9mudU1WyADzjcXYzwXW78+XJbvTl5W8pHicg7RBWPBRlU39qb2VMDPlhTVVynPToK/sM2uI1YmVyKykZkIlnULf3577ejJ38U2L0JqPOtC9RHV59uyUG6FubdGxpZkbkVD84kWFt06ClChbYsxJo9PQ3VhRoA3/gBdV02PY7kExFcHK8hrvVcP4bF2Au/AllBZqMamQuU2aK2zMcAucbRphNp8FyKXxJxIxTKTaACMAMsGA8h4tZyuhnBovYDFaHyOJWh/dLwJLWMY/sPAssAeWQrNK6Hy9oIZkX3sq2q2+OaF/1YcMVaG44JacyINuqU1bi+AgYCg0sY73nRMjBO3sXP3DO/BPtkLAMGD4SjqwfWgF02uWd/EVIhQ+QVKGtrTAzPCJBVkPZYLXpZiEnHdedJ4Cc0a85nSZBQ3gMf4fHiTes7AHLKW1jnmRN4+JQDFgJoMTE5+b7aO9xyqKYWFXDH9M4FbuS/ty/doZx2ejvU6LjXgLQ+ubzIxB/nJzhg7dQ3NbuJ0eTghimMtuzrbg8nraTZXRwTgR5sglbcu/ZoxKDWdMV2Nms8X2c80RYOpbGtKz4rWmLJng3TJyb6jHXXAjcQ/fEMEsaBbO2X0a+6Q3lKTOG5xZkrwvEWOXH75zZ7qfxQZ78Jaq4V50PH2n6M1gIWI6ULCrDW2jvxePC1Ei4zLHeys/6IDYvBbIh5GzHf1aCVQswvPI754E/6QPAb1FVofpkSET/vGb6B1jTzbTeOuFm7Luiw+QIvkaBi3PPhBOEMFmje5BUpb5kUfdF1xeQraAY5PWbuUBDTMtij2D1zeDYVRPGVIlEXlPw8xXUxzYhtFGpCxTFdwes+oj9WbLQowr+mfZoh9kbyVAVrzVfiUcfA71alYRbgz6CQeK8JNzepN4U4ntdJQGphpiDViZnPHkAfEp/PCWekxRt09VqsafxyskQlvqPgVcGNG/EvtJmZ+lZCa9+jgPdT9KqFaeVXBfH9TtuxUoKskIjf/qLckjLodsij6gowMm45laF4BZxuK1FJozOHaJmmeeA="
-let decrypted;
-try {
-  decrypted = decipher.update(encrypted, 'base64', 'utf8') + decipher.final('utf8');
-} catch (e) {
-  console.error(
-    `${errorPrefix}The value for the ${iSponsorGraphile} environmental variable (value: '${password.slice(
-      0,
-      2,
-    )}...${password.slice(-2)}') is incorrect.${errorSuffix}`,
-  );
-  process.exit(42);
-}
-
 // Convince Node to allow ESM named imports
 
 
-// Load our decrypted module
-eval(decrypted);
+// 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)}])));