grafast 0.1.1-beta.20 → 0.1.1-beta.21

package/dist/prepare.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.grafastPrepare = void 0;
+exports.grafastPrepare = grafastPrepare;
 const tslib_1 = require("tslib");
 const graphql = tslib_1.__importStar(require("graphql"));
 const execute_1 = require("graphql/execution/execute");
@@ -228,7 +228,7 @@ function executePreemptive(args, operationPlan, variableValues, context, rootVal
             const [ctx, result] = outputBucket(operationPlan.rootOutputPlan, subscriptionBucket, ZERO, requestContext, [], rootBucket.store
                 .get(operationPlan.variableValuesStep.id)
                 .at(rootBucketIndex), outputDataAsString);
-            return finalize(result, ctx, index === 0 ? rootValue[interfaces_js_1.$$extensions] ?? undefined : undefined, outputDataAsString);
+            return finalize(result, ctx, index === 0 ? (rootValue[interfaces_js_1.$$extensions] ?? undefined) : undefined, outputDataAsString);
         }
         if ((0, utils_js_1.isPromiseLike)(bucketPromise)) {
             return bucketPromise.then(outputStreamBucket);
@@ -265,6 +265,7 @@ function executePreemptive(args, operationPlan, variableValues, context, rootVal
             }
             return payload;
         }
+        // NOTE: this is where we determine whether to stream or not
         if (bucketRootValue != null &&
             subscriptionLayerPlan != null &&
             Array.isArray(bucketRootValue) &&
@@ -399,7 +400,6 @@ function grafastPrepare(args, options = {}) {
     const executionTimeout = options.timeouts?.execution ?? null;
     return executePreemptive(args, operationPlan, variableValues, context, rootValue, options.outputDataAsString ?? false, executionTimeout);
 }
-exports.grafastPrepare = grafastPrepare;
 function newIterator(abort) {
     const valueQueue = [];
     const pullQueue = [];
@@ -417,7 +417,7 @@ function newIterator(abort) {
             const cbs = pullQueue.shift();
             if (cbs !== undefined) {
                 if ((0, utils_js_1.isPromiseLike)(v)) {
-                    v.then((v) => cbs[0]({ done, value: v }), (e) => {
+                    v.then((v) => cbs[0]({ done: false, value: v }), (e) => {
                         try {
                             const r = cbs[1](e);
                             if ((0, utils_js_1.isPromiseLike)(r)) {
@@ -431,7 +431,7 @@ function newIterator(abort) {
                     });
                 }
                 else {
-                    cbs[0]({ done, value: v });
+                    cbs[0]({ done: false, value: v });
                 }
             }
             else {
@@ -463,7 +463,7 @@ function newIterator(abort) {
                 abort();
                 for (const entry of pullQueue) {
                     try {
-                        entry[0]({ done, value: undefined });
+                        entry[0]({ done: true, value: undefined });
                     }
                     catch (e) {
                         // ignore

package/dist/step.d.ts

@@ -1,47 +1,21 @@
 import type { GraphQLObjectType } from "graphql";
 import type { LayerPlan, LayerPlanReasonSubroutine } from "./engine/LayerPlan.js";
 import type { OperationPlan } from "./engine/OperationPlan.js";
-import type { AddDependencyOptions, ExecutionDetails, ExecutionEntryFlags, GrafastResultsList, GrafastResultStreamList, JSONValue, PromiseOrDirect, StepOptimizeOptions, StreamDetails, UnbatchedExecutionExtra } from "./interfaces.js";
+import type { AddDependencyOptions, DependencyOptions, ExecutionDetails, ExecutionEntryFlags, ExecutionResults, GrafastResultsList, JSONValue, PromiseOrDirect, StepOptimizeOptions, UnbatchedExecutionExtra } from "./interfaces.js";
 import { $$subroutine } from "./interfaces.js";
-import type { __ItemStep } from "./steps/index.js";
-declare function reallyAssertFinalized(plan: BaseStep): void;
+import type { __FlagStep, __ItemStep } from "./steps/index.js";
+declare function reallyAssertFinalized(plan: Step): void;
 export declare const assertFinalized: typeof reallyAssertFinalized;
 /**
- * The base abstract plan type; you should not extend this directly - instead
- * use an ExecutableStep (for use when planning output fields) or a
- * ModifierStep (for use when planning arguments/input fields).
- *
- * @remarks
- *
- * Though it might seem that ModifierStep should be used for all inputs
- * (arguments, input objects), this is not the case. When planning an output
- * field, all inputs to it (including arguments, parent plan, context, etc)
- * should be other executable plans. The only time that ModifierStep is used is
- * when writing specific plans as part of the argument or input field
- * definitions themself; even in these cases the inputs to these plan resolvers
- * will be ExecutablePlans.
+ * Executable plans are the plans associated with leaves on the GraphQL tree,
+ * they must be able to execute to return values.
  */
-export declare abstract class BaseStep {
+export declare class Step<TData = any> {
     readonly operationPlan: OperationPlan;
     [$$subroutine]: LayerPlan<LayerPlanReasonSubroutine> | null;
     isArgumentsFinalized: boolean;
     isFinalized: boolean;
     debug: boolean;
-    constructor();
-    toString(): string;
-    /**
-     * This metadata will be merged into toString when referencing this plan.
-     */
-    toStringMeta(): string | null;
-    planJSONExtra(): Record<string, JSONValue | undefined> | undefined;
-    finalize(): void;
-    destroy(): void;
-}
-/**
- * Executable plans are the plans associated with leaves on the GraphQL tree,
- * they must be able to execute to return values.
- */
-export declare class ExecutableStep<TData = any> extends BaseStep {
     static $$export: any;
     /**
      * Setting this true is a performance optimisation, but it comes with strong
@@ -73,13 +47,7 @@ export declare class ExecutableStep<TData = any> extends BaseStep {
     /**
      * The plan this plan will need data from in order to execute.
      */
-    protected readonly dependencies: ReadonlyArray<ExecutableStep>;
-    /**
-     * What execution entry flags we can't handle for the given indexed dependency
-     * (default = this.defaultForbiddenFlags)
-     */
-    protected readonly dependencyForbiddenFlags: ReadonlyArray<ExecutionEntryFlags>;
-    protected readonly dependencyOnReject: ReadonlyArray<Error | null | undefined>;
+    protected readonly dependencies: ReadonlyArray<Step>;
     /**
      * Unique identifier for this step within the plan.
      */
@@ -126,17 +94,29 @@ export declare class ExecutableStep<TData = any> extends BaseStep {
      */
     hasSideEffects: boolean;
     constructor();
+    /**
+     * Generally you should only use this once the dependencies of a step are
+     * established, if you use it beforehand and it returns `true` then adding a
+     * non-unary dependency later will result in an error.
+     */
+    getAndFreezeIsUnary(): boolean;
     protected withMyLayerPlan<T>(callback: () => T): T;
-    protected getStep(id: number): ExecutableStep;
-    protected getDepOptions(depId: number): AddDependencyOptions;
-    protected getDep(_depId: number): ExecutableStep;
+    /** @experimental */
+    withLayerPlan<T>(callback: () => T): T;
+    protected getStep(id: number): Step;
+    protected getDepOptions<TStep extends Step = Step>(depId: number): DependencyOptions<TStep>;
+    protected getDep<TStep extends Step = Step>(_depId: number): TStep | __FlagStep<TStep>;
+    protected getDep<TStep extends Step = Step>(_depId: number, throwOnFlagged: true): TStep;
+    protected maybeGetDep<TStep extends Step = Step>(depId: number | null | undefined): TStep | __FlagStep<TStep> | null;
+    protected maybeGetDep<TStep extends Step = Step>(depId: number | null | undefined, throwOnFlagged: true): TStep | null;
+    protected getDepOrConstant<TData = any>(_depId: number | null, _fallback: TData): Step<TData>;
     /**
      * Like getDep, except it skips over __ItemStep and similar steps to get to
      * where the parent really is.
      *
      * @experimental
      */
-    protected getDepDeep(depId: number): ExecutableStep;
+    protected getDepDeep(depId: number): Step;
     /**
      * Cache a generated step by a given identifier (cacheKey) such that we don't
      * need to regenerate it on future calls, significantly reducing the load on
@@ -144,17 +124,22 @@ export declare class ExecutableStep<TData = any> extends BaseStep {
      *
      * @experimental
      */
-    protected cacheStep<T extends ExecutableStep>(actionKey: string, cacheKey: symbol | string | number, cb: () => T): T;
+    protected cacheStep<T extends Step>(actionKey: string, cacheKey: symbol | string | number, cb: () => T): T;
     toString(): string;
-    protected canAddDependency(step: ExecutableStep): boolean;
-    protected addDependency(stepOrOptions: ExecutableStep | AddDependencyOptions): number;
+    /**
+     * This metadata will be merged into toString when referencing this plan.
+     */
+    toStringMeta(): string | null;
+    planJSONExtra(): Record<string, JSONValue | undefined> | undefined;
+    protected canAddDependency(step: Step): boolean;
+    protected addDependency(stepOrOptions: Step | AddDependencyOptions): number;
     /**
      * Adds "unary" dependencies; in `execute({count, values})` you'll receive a
      * `values[index]` (where `index` is the return value of this function) with
      * `isBatch = false` so you can use the `values[index].value` property
      * directly.
      */
-    protected addUnaryDependency(stepOrOptions: ExecutableStep | AddDependencyOptions): number;
+    protected addUnaryDependency(stepOrOptions: Step | AddDependencyOptions): number;
     /**
      * Given a list of "peer" steps, return a list of these `peers` that are
      * equivalent to this step.
@@ -165,17 +150,17 @@ export declare class ExecutableStep<TData = any> extends BaseStep {
      * If you need to transform the peer to be equivalent you should do so via
      * the `deduplicatedWith` callback later.
      */
-    deduplicate?(_peers: readonly ExecutableStep[]): readonly ExecutableStep[];
+    deduplicate?(_peers: readonly Step[]): readonly Step[];
     /**
      * If this plan is replaced via deduplication, this method gives it a chance
      * to hand over its responsibilities to its replacement.
      */
-    deduplicatedWith?(replacement: ExecutableStep): void;
+    deduplicatedWith?(replacement: Step): void;
     /**
      * Our chance to optimise the plan (which could go as far as to inline the
      * plan into the parent plan).
      */
-    optimize?(_options: StepOptimizeOptions): ExecutableStep;
+    optimize?(_options: StepOptimizeOptions): Step;
     finalize(): void;
     /**
      * This function will be called with 'execution details', an object containing:
@@ -202,10 +187,10 @@ export declare class ExecutableStep<TData = any> extends BaseStep {
      * add attributes to meta for each purpose (e.g. use `meta.cache` for
      * memoizing results) so that you can expand your usage of meta in future.
      */
-    execute(details: ExecutionDetails): PromiseOrDirect<GrafastResultsList<TData>>;
+    execute(details: ExecutionDetails): ExecutionResults<TData>;
     destroy(): void;
 }
-export declare abstract class UnbatchedExecutableStep<TData = any> extends ExecutableStep<TData> {
+export declare abstract class UnbatchedStep<TData = any> extends Step<TData> {
     static $$export: {
         moduleName: string;
         exportName: string;
@@ -214,62 +199,45 @@ export declare abstract class UnbatchedExecutableStep<TData = any> extends Execu
     execute({ indexMap, values, extra, }: ExecutionDetails): PromiseOrDirect<GrafastResultsList<TData>>;
     abstract unbatchedExecute(extra: UnbatchedExecutionExtra, ...tuple: any[]): PromiseOrDirect<TData>;
 }
-export declare function isExecutableStep<TData = any>(step: unknown): step is ExecutableStep<TData>;
-export declare function assertExecutableStep<TData>(step: BaseStep): asserts step is ExecutableStep<TData>;
-export declare function isUnbatchedExecutableStep<TData = any>(step: unknown): step is UnbatchedExecutableStep<TData>;
+export declare function isStep<TData = any>(step: unknown): step is Step<TData>;
+export declare function assertStep<TData>(step: unknown): asserts step is Step<TData>;
+export declare function isUnbatchedStep<TData = any>(step: unknown): step is UnbatchedStep<TData>;
 export type ObjectLikeStep<TData extends {
-    [key: string]: ExecutableStep;
+    [key: string]: Step;
 } = {
-    [key: string]: ExecutableStep;
-}> = ExecutableStep<{
-    [key in keyof TData]: TData[key] extends ExecutableStep<infer U> ? U : never;
+    [key: string]: Step;
+}> = Step<{
+    [key in keyof TData]: TData[key] extends Step<infer U> ? U : never;
 }> & {
-    get<TKey extends keyof TData>(key: TKey): ExecutableStep<TData[TKey]>;
+    get<TKey extends keyof TData>(key: TKey): Step<TData[TKey]>;
 };
 export declare function isObjectLikeStep<TData extends {
-    [key: string]: ExecutableStep;
+    [key: string]: Step;
 } = {
-    [key: string]: ExecutableStep;
-}>(plan: ExecutableStep): plan is ObjectLikeStep<TData>;
-export type ListLikeStep<TData extends [...ExecutableStep[]] = [...ExecutableStep[]]> = ExecutableStep<{
-    [key in keyof TData]: TData[key] extends ExecutableStep<infer U> ? U : never;
+    [key: string]: Step;
+}>(plan: Step): plan is ObjectLikeStep<TData>;
+export type ListLikeStep<TData extends [...Step[]] = [...Step[]]> = Step<{
+    [key in keyof TData]: TData[key] extends Step<infer U> ? U : never;
 }> & {
-    at<TKey extends keyof TData>(key: TKey): ExecutableStep<TData[TKey]>;
+    at<TKey extends keyof TData>(key: TKey): Step<TData[TKey]>;
 };
-export declare function isListLikeStep<TData extends [...ExecutableStep[]] = [...ExecutableStep[]]>(plan: ExecutableStep): plan is ListLikeStep<TData>;
-export type StreamableStep<TData> = ExecutableStep<ReadonlyArray<TData>> & {
-    stream(details: StreamDetails): PromiseOrDirect<GrafastResultStreamList<TData>>;
+export declare function isListLikeStep<TData extends [...Step[]] = [...Step[]]>(plan: Step): plan is ListLikeStep<TData>;
+export type PolymorphicStep = Step & {
+    planForType(objectType: GraphQLObjectType): Step;
 };
-export declare function isStreamableStep<TData>(plan: ExecutableStep<ReadonlyArray<TData>>): plan is StreamableStep<TData>;
-export type PolymorphicStep = ExecutableStep & {
-    planForType(objectType: GraphQLObjectType): ExecutableStep;
-};
-export declare function isPolymorphicStep(s: ExecutableStep): s is PolymorphicStep;
-/**
- * Modifier plans modify their parent plan (which may be another ModifierStep
- * or an ExecutableStep). First they gather all the requirements from their
- * children (if any) being applied to them, then they apply themselves to their
- * parent plan. This application is done through the `apply()` method.
- *
- * Modifier plans do not use dependencies.
- */
-export declare abstract class ModifierStep<TParentStep extends BaseStep = BaseStep> extends BaseStep {
-    protected readonly $parent: TParentStep;
-    static $$export: any;
-    readonly id: string;
-    constructor($parent: TParentStep);
-    toString(): string;
-    /**
-     * In this method, you should apply the changes to your `this.$parent` plan
-     */
-    abstract apply(): void;
-}
-export declare function isModifierStep<TParentStep extends ExecutableStep | ModifierStep<any>>(plan: BaseStep): plan is ModifierStep<TParentStep>;
-export declare function assertModifierStep<TParentStep extends ExecutableStep | ModifierStep<any>>(plan: BaseStep, pathDescription: string): asserts plan is ModifierStep<TParentStep>;
-export interface ListCapableStep<TOutputData, TItemStep extends ExecutableStep<TOutputData> = ExecutableStep<TOutputData>> extends ExecutableStep<ReadonlyArray<any>> {
+export declare function isPolymorphicStep(s: Step): s is PolymorphicStep;
+export interface ListCapableStep<TOutputData, TItemStep extends Step<TOutputData> = Step<TOutputData>> extends Step<ReadonlyArray<any>> {
     listItem(itemPlan: __ItemStep<this>): TItemStep;
 }
-export declare function isListCapableStep<TData, TItemStep extends ExecutableStep<TData>>(plan: ExecutableStep<ReadonlyArray<TData>>): plan is ListCapableStep<TData, TItemStep>;
-export declare function assertListCapableStep<TData, TItemStep extends ExecutableStep<TData>>(plan: ExecutableStep<ReadonlyArray<TData>>, pathDescription: string): asserts plan is ListCapableStep<TData, TItemStep>;
-export {};
+export declare function isListCapableStep<TData, TItemStep extends Step<TData>>(plan: Step<ReadonlyArray<TData>>): plan is ListCapableStep<TData, TItemStep>;
+export declare function assertListCapableStep<TData, TItemStep extends Step<TData>>(plan: Step<ReadonlyArray<TData>>, pathDescription: string): asserts plan is ListCapableStep<TData, TItemStep>;
+export { 
+/** @deprecated Use ExecutableStep instead */
+Step as ExecutableStep, 
+/** @deprecated Use UnbatchedStep instead */
+UnbatchedStep as UnbatchedExecutableStep, };
+/** @deprecated Use isStep instead */
+export declare const isExecutableStep: typeof isStep;
+/** @deprecated Use isStep instead */
+export declare function assertExecutableStep<TData>(step: unknown): asserts step is Step<TData>;
 //# sourceMappingURL=step.d.ts.map