grafast 0.1.1-beta.4 → 0.1.1-beta.6

package/dist/bucket.d.ts

@@ -1,90 +1,2 @@
-import type { LayerPlan } from "./engine/LayerPlan";
-import type { MetaByMetaKey } from "./engine/OperationPlan";
-import type { ExecutionEventEmitter } from "./interfaces.js";
-/**
- * @internal
- */
-export interface RequestTools {
-    /** The `timeSource.now()` at which the request started executing */
-    startTime: number;
-    /** The `timeSource.now()` at which the request should stop executing (if a timeout was configured) */
-    stopTime: number | null;
-    readonly eventEmitter: ExecutionEventEmitter | undefined;
-    /**
-     * If we're running inside GraphQL then we should not serialize scalars,
-     * otherwise we'll face the double-serialization problem.
-     */
-    insideGraphQL: false;
-}
-/**
- * A "bucket" is where the results from plans are stored so that other plans
- * can retrieve them, it may take on different forms depending on the mode of
- * execution. A "LayerPlan" is used to both identify the bucket and to specify
- * why it exists and how it behaves.
- *
- * Every `ExecutableStep` belongs to exactly one LayerPlan (and thus bucket),
- * specified by `plan.layerPlan`.
- *
- * @internal
- */
-export interface Bucket {
-    /**
-     * The LayerPlan definition this bucket adheres to
-     */
-    layerPlan: LayerPlan;
-    /**
-     * How many entries are there in the bucket?
-     */
-    size: number;
-    /**
-     * The polymorphic path through which each of the entries (respectively) has
-     * travelled. This influences the steps that will be executed using the
-     * related inputs.
-     */
-    polymorphicPathList: readonly (string | null)[];
-    /**
-     * These are the iterators the bucket (or its descendents, without crossing a
-     * stream/defer boundary) have created (if any). Each of these must either be
-     * processed via `processRoot`, or must be manually released (via
-     * `releaseUnusedIterators`) otherwise a memory leak could occur.
-     */
-    iterators: Array<Set<AsyncIterator<any> | Iterator<any>>>;
-    /**
-     * `metaByMetaKey` belongs to the bucket rather than the request context
-     * because mutations and subscriptions shouldn't re-use caches.
-     *
-     * TODO: `inheritMeta: boolean`?
-     */
-    metaByMetaKey: MetaByMetaKey;
-    /**
-     * Every entry in the store is a list with the same length as the bucket has
-     * `size`.
-     *
-     * The entry for '-1' is the request indexes, so we can associate the results
-     * back to the request that triggered them.
-     */
-    store: Map<number, any[]>;
-    /**
-     * Set this true when the bucket is fully executed.
-     *
-     * Initialize it to false.
-     */
-    isComplete: boolean;
-    /**
-     * If an error occurred at any stage we need to drop down to more careful
-     * (and slower) handling.
-     *
-     * Initialize it to false.
-     */
-    hasErrors: boolean;
-    /**
-     * The child buckets of this bucket.
-     */
-    children: {
-        [layerPlanId: number]: {
-            bucket: Bucket;
-            map: Map<number, number | number[]>;
-        };
-    };
-}
+export {};
 //# sourceMappingURL=bucket.d.ts.map

package/dist/dev.d.ts

@@ -1,6 +1,2 @@
-/**
- * @internal
- */
-export declare const isDev: boolean;
 export declare function noop(): void;
 //# sourceMappingURL=dev.d.ts.map

package/dist/dev.js

@@ -4,7 +4,24 @@ exports.noop = exports.isDev = void 0;
 /**
  * @internal
  */
-exports.isDev = typeof process !== "undefined" && process.env.GRAPHILE_ENV === "development";
+const graphileEnv = typeof process !== "undefined" ? process.env.GRAPHILE_ENV : undefined;
+const nodeEnv = typeof process !== "undefined" ? process.env.NODE_ENV : undefined;
+/**
+ * @internal
+ */
+exports.isDev = graphileEnv !== undefined
+    ? graphileEnv === "development" || graphileEnv === "test"
+    : nodeEnv === "development" || nodeEnv === "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) {
+    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.`);
+}
 //# sourceMappingURL=dev.js.map

package/dist/engine/LayerPlan.d.ts

@@ -1,5 +1,5 @@
 import type { Bucket } from "../bucket.js";
-import type { ExecutableStep, ModifierStep, UnbatchedExecutableStep } from "../step";
+import type { ExecutableStep } from "../step";
 import type { OperationPlan } from "./OperationPlan";
 /** Non-branching, non-deferred */
 export interface LayerPlanReasonRoot {
@@ -71,43 +71,6 @@ export type HasParent<A extends LayerPlanReason> = A extends any ? A extends {
     parentStep: ExecutableStep;
 } ? A : never : never;
 export type LayerPlanReasonsWithParentStep = HasParent<LayerPlanReason>;
-/** @internal */
-export interface LayerPlanPhase {
-    /**
-     * If true, we should check before the layer plan executes to see if the
-     * execution has already timed out.
-     *
-     * @see {@link RequestTools.stopTime}
-     */
-    checkTimeout: boolean;
-    /**
-     * A list of steps that can be ran in parallel at this point, since all
-     * their previous dependencies have already been satisfied.
-     */
-    normalSteps: Array<{
-        step: ExecutableStep;
-    }> | undefined;
-    /**
-     * A list of 'isSyncAndSafe' steps with unbatchedExecute methods that can be
-     * ran once the `normalSteps` have completed; they must only depend on steps
-     * that have already been executed before them (including previous
-     * unbatchedSyncAndSafeSteps in the same list).
-     */
-    unbatchedSyncAndSafeSteps: Array<{
-        step: UnbatchedExecutableStep;
-        /**
-         * Store the result of the step here if you want - useful to avoid lookups
-         * and when there's no storage. HIGHLY VOLATILE, will not survive a tick!
-         */
-        scratchpad: any;
-    }> | undefined;
-    /**
-     * Optimization - a digest of all steps in normalSteps and unbatchedSyncAndSafeSteps
-     *
-     * @internal
-     */
-    _allSteps: ExecutableStep[];
-}
 /**
  * A LayerPlan represents (via "reason") either the root (root), when something
  * happens at a later time (mutationField, defer), when plurality changes
@@ -138,58 +101,6 @@ export declare class LayerPlan<TReason extends LayerPlanReason = LayerPlanReason
     parentLayerPlan: LayerPlan | null;
     readonly reason: TReason;
     id: number;
-    /**
-     * Every layer plan has a "root step" that shapes the value the layer
-     * returns. Note that this step may be dependent on other steps included in
-     * the LayerPlan, or could be provided externally.
-     *
-     * The root step is different for different layer step reasons:
-     *
-     * - root: the `operationPlan.rootValue`
-     * - listItem: the `__ItemStep`
-     * - stream: also the `__ItemStep`
-     * - subscription: also the `__ItemStep`
-     * - mutationField: the result plan of the mutation field
-     * - defer: the parent layer's rootStep (defer always results in an object, unless an error occurs)
-     * - polymorphic: the plan for the particular type
-     * - subroutine: the result (returned) plan of the subroutine
-     *
-     * @internal
-     */
-    readonly rootStep: ExecutableStep | null;
-    /**
-     * Which plans the results for which are available in a parent bucket need to
-     * be "copied across" to this bucket because plans in this bucket still
-     * reference them?
-     *
-     * @internal
-     */
-    copyStepIds: number[];
-    /** @internal */
-    children: LayerPlan[];
-    /** @internal */
-    steps: ExecutableStep[];
-    /** @internal */
-    pendingSteps: ExecutableStep[];
-    /**
-     * Describes the order in which the steps within this LayerPlan are executed.
-     *
-     * Special attention must be paid to steps that have side effects.
-     *
-     * @internal
-     */
-    phases: Array<LayerPlanPhase>;
-    /**
-     * The list of layerPlans that steps added to this LayerPlan may depend upon.
-     * Note this includes self, so it has one more entry than `depth`.
-     *
-     * ```
-     * this.ancestry[this.depth] === this;
-     * ```
-     *
-     * @internal
-     */
-    ancestry: LayerPlan[];
     /** How "deep" this layer plan is (how many ancestors it has). The root layer plan has a depth of 0. */
     depth: number;
     /** The depth at which a "defer boundary" occurs (OperationPlan.getPeers cannot pass a defer boundary), or 0. */
@@ -203,12 +114,6 @@ export declare class LayerPlan<TReason extends LayerPlanReason = LayerPlanReason
     toString(): string;
     print(depth?: number): string;
     setRootStep($root: ExecutableStep): void;
-    /** @internal Use plan.getStep(id) instead. */
-    getStep(id: number, requestingStep: ExecutableStep): ExecutableStep;
-    /** @internal */
-    _addStep(step: ExecutableStep): number;
-    /** @internal */
-    _addModifierStep(step: ModifierStep<any>): string;
     finalize(): void;
     newBucket(parentBucket: Bucket): Bucket | null;
 }

package/dist/engine/OperationPlan.d.ts

@@ -1,16 +1,14 @@
 import type { FragmentDefinitionNode, GraphQLFieldMap, GraphQLObjectType, GraphQLSchema, GraphQLUnionType, OperationDefinitionNode } from "graphql";
-import type { Constraint } from "../constraints.js";
 import type { SelectionSetDigest } from "../graphqlCollectFields.js";
-import type { GrafastPlanJSON, ModifierStep } from "../index.js";
-import { __TrackedValueStep, __ValueStep, ExecutableStep } from "../index.js";
+import type { GrafastPlanJSON } from "../index.js";
+import { ExecutableStep } from "../index.js";
 import { $$timeout, $$ts } from "../interfaces.js";
 import type { LayerPlanReasonSubroutine } from "./LayerPlan.js";
 import { LayerPlan } from "./LayerPlan.js";
 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 */
+/** Beware: the list of phases may change over time... @experimental */
 export type OperationPlanPhase = "init" | "plan" | "validate" | "optimize" | "finalize" | "ready";
 export interface MetaByMetaKey {
     [metaKey: string | number | symbol]: Record<string, any>;
@@ -49,62 +47,17 @@ export declare class OperationPlan {
      * 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.
      */
@@ -123,35 +76,6 @@ 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.
@@ -204,13 +128,6 @@ export declare class OperationPlan {
     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
@@ -268,12 +185,6 @@ export declare class OperationPlan {
     private walkOutputPlans;
     generatePlanJSON(): GrafastPlanJSON;
     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: {
         new (...args: any[]): TClass;