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

package/dist/makeGrafastSchema.d.ts

@@ -1,7 +1,8 @@
 import type { GraphQLFieldResolver, GraphQLScalarLiteralParser, GraphQLScalarSerializer, GraphQLScalarValueParser } from "graphql";
 import { GraphQLSchema } from "graphql";
-import type { EnumValueApplyPlanResolver, FieldPlanResolver, ScalarPlanResolver } from "./interfaces.js";
-import type { ExecutableStep } from "./step.js";
+import * as graphql from "graphql";
+import type { ArgumentApplyPlanResolver, EnumValueApplyResolver, FieldPlanResolver, InputObjectFieldApplyResolver, InputObjectTypeBakedResolver, ScalarPlanResolver } from "./interfaces.js";
+import type { Step } from "./step.js";
 /**
  * When defining a field with `typeDefs/plans` you can declare the field plan
  * directly, or you can define a configuration object that accepts the plan and
@@ -13,15 +14,19 @@ export type FieldPlans = FieldPlanResolver<any, any, any> | {
     resolve?: GraphQLFieldResolver<any, any>;
     subscribe?: GraphQLFieldResolver<any, any>;
     args?: {
-        [argName: string]: Grafast.ArgumentExtensions;
+        [argName: string]: ArgumentApplyPlanResolver | {
+            applyPlan?: ArgumentApplyPlanResolver;
+            applySubscribePlan?: ArgumentApplyPlanResolver;
+            extensions?: graphql.GraphQLArgumentExtensions;
+        };
     };
 };
 /**
  * The plans/config for each field of a GraphQL object type.
  */
 export type ObjectPlans = {
-    __assertStep?: ((step: ExecutableStep) => asserts step is ExecutableStep) | {
-        new (...args: any[]): ExecutableStep;
+    __assertStep?: ((step: Step) => asserts step is Step) | {
+        new (...args: any[]): Step;
     };
 } & {
     [fieldName: string]: FieldPlans;
@@ -30,9 +35,12 @@ export type ObjectPlans = {
  * The plans for each field of a GraphQL input object type.
  */
 export type InputObjectPlans = {
-    __inputPlan?: () => ExecutableStep;
+    __baked?: InputObjectTypeBakedResolver;
 } & {
-    [fieldName: string]: Grafast.InputFieldExtensions;
+    [fieldName: string]: InputObjectFieldApplyResolver<any> | {
+        apply?: InputObjectFieldApplyResolver<any>;
+        extensions?: graphql.GraphQLInputFieldExtensions;
+    };
 };
 /**
  * The plan config for an interface or union type.
@@ -53,9 +61,10 @@ export type ScalarPlans = {
  * The values/configs for the entries in a GraphQL enum type.
  */
 export type EnumPlans = {
-    [enumValueName: string]: EnumValueApplyPlanResolver | string | number | boolean | {
+    [enumValueName: string]: EnumValueApplyResolver | string | number | boolean | {
         value?: unknown;
-        applyPlan?: EnumValueApplyPlanResolver;
+        extensions?: graphql.GraphQLEnumValueExtensions;
+        apply?: EnumValueApplyResolver;
     };
 };
 /**

package/dist/makeGrafastSchema.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeGrafastSchema = void 0;
+exports.makeGrafastSchema = makeGrafastSchema;
 const tslib_1 = require("tslib");
 const graphql_1 = require("graphql");
 const graphql = tslib_1.__importStar(require("graphql"));
@@ -82,7 +82,7 @@ function makeGrafastSchema(details) {
                             for (const [argName, _argSpec] of Object.entries(fieldSpec.args)) {
                                 const arg = field.args?.[argName];
                                 if (!arg) {
-                                    console.warn(`'plans' specified configuration for object type '${typeName}' field '${fieldName}' arg '${argName}', but that arg was not present in the type`);
+                                    console.warn(`'plans' specified configuration for object type '${typeName}' field '${fieldName}' arg '${argName}', but that arg was not present on the field`);
                                     continue;
                                 }
                             }
@@ -98,12 +98,19 @@ function makeGrafastSchema(details) {
                         if (fieldName.startsWith("__")) {
                             continue;
                         }
-                        const fieldSpec = objectPlans?.[fieldName];
+                        const fieldSpec = objectPlans && Object.hasOwn(objectPlans, fieldName)
+                            ? objectPlans[fieldName]
+                            : undefined;
                         const fieldConfig = {
                             ...rawFieldSpec,
                             type: mapType(rawFieldSpec.type),
                         };
                         fields[fieldName] = fieldConfig;
+                        if (fieldConfig.args) {
+                            for (const [_argName, arg] of Object.entries(fieldConfig.args)) {
+                                arg.type = mapType(arg.type);
+                            }
+                        }
                         if (fieldSpec) {
                             if (typeof fieldSpec === "function") {
                                 (0, utils_js_1.exportNameHint)(fieldSpec, `${typeName}_${fieldName}_plan`);
@@ -134,18 +141,30 @@ function makeGrafastSchema(details) {
                                 }
                                 if (fieldConfig.args) {
                                     for (const [argName, arg] of Object.entries(fieldConfig.args)) {
-                                        arg.type = mapType(arg.type);
                                         const argSpec = fieldSpec.args?.[argName];
                                         if (typeof argSpec === "function") {
-                                            // Invalid
-                                            throw new Error(`Invalid configuration for plans.${typeName}.${fieldName}.args.${argName} - saw a function, but expected an object with 'inputPlan' (optional) and 'applyPlan' (optional) plans`);
+                                            const applyPlan = argSpec;
+                                            (0, utils_js_1.exportNameHint)(applyPlan, `${typeName}_${fieldName}_${argName}_applyPlan`);
+                                            Object.assign(arg.extensions, {
+                                                grafast: { applyPlan },
+                                            });
                                         }
-                                        else if (argSpec) {
-                                            (0, utils_js_1.exportNameHint)(argSpec.applyPlan, `${typeName}_${fieldName}_${argName}_applyPlan`);
-                                            (0, utils_js_1.exportNameHint)(argSpec.inputPlan, `${typeName}_${fieldName}_${argName}_inputPlan`);
-                                            const grafastExtensions = Object.create(null);
-                                            arg.extensions.grafast = grafastExtensions;
-                                            Object.assign(grafastExtensions, argSpec);
+                                        else if (typeof argSpec === "object" &&
+                                            argSpec !== null) {
+                                            const { extensions, applyPlan, applySubscribePlan } = argSpec;
+                                            if (extensions) {
+                                                Object.assign(arg.extensions, extensions);
+                                            }
+                                            if (applyPlan || applySubscribePlan) {
+                                                (0, utils_js_1.exportNameHint)(applyPlan, `${typeName}_${fieldName}_${argName}_applyPlan`);
+                                                (0, utils_js_1.exportNameHint)(applySubscribePlan, `${typeName}_${fieldName}_${argName}_applySubscribePlan`);
+                                                Object.assign(arg.extensions, {
+                                                    grafast: {
+                                                        applyPlan,
+                                                        applySubscribePlan,
+                                                    },
+                                                });
+                                            }
                                         }
                                     }
                                 }
@@ -170,39 +189,51 @@ function makeGrafastSchema(details) {
                 const inputObjectPlans = plans[astType.name];
                 if (inputObjectPlans) {
                     for (const [fieldName, fieldSpec] of Object.entries(inputObjectPlans)) {
-                        if (fieldName === "__inputPlan") {
-                            config.extensions.grafast.inputPlan =
+                        if (fieldName === "__baked") {
+                            config.extensions.grafast.baked =
                                 fieldSpec;
                             continue;
                         }
+                        if (config.extensions?.grafast?.baked) {
+                            (0, utils_js_1.exportNameHint)(config.extensions.grafast.baked, `${typeName}__baked`);
+                        }
                         const field = rawConfig.fields[fieldName];
                         if (!field) {
                             console.warn(`'plans' specified configuration for input object type '${typeName}' field '${fieldName}', but that field was not present in the type`);
                             continue;
                         }
-                        if (typeof fieldSpec === "function") {
-                            throw new Error(`Expected input object type '${typeName}' field '${fieldName}' to be an object, but found a function. We don't know if this should be the 'inputPlan' or 'applyPlan' - please supply an object.`);
-                        }
                     }
                 }
                 const rawFields = rawConfig.fields;
                 config.fields = function () {
                     const fields = Object.create(null);
                     for (const [fieldName, rawFieldConfig] of Object.entries(rawFields)) {
-                        const fieldSpec = inputObjectPlans?.[fieldName];
+                        const fieldSpec = inputObjectPlans && Object.hasOwn(inputObjectPlans, fieldName)
+                            ? inputObjectPlans[fieldName]
+                            : undefined;
                         const fieldConfig = {
                             ...rawFieldConfig,
                             type: mapType(rawFieldConfig.type),
                         };
                         fields[fieldName] = fieldConfig;
                         if (fieldSpec) {
-                            (0, utils_js_1.exportNameHint)(fieldSpec.inputPlan, `${typeName}_${fieldName}_inputPlan`);
-                            (0, utils_js_1.exportNameHint)(fieldSpec.applyPlan, `${typeName}_${fieldName}_applyPlan`);
+                            const grafastExtensions = Object.create(null);
+                            fieldConfig.extensions.grafast = grafastExtensions;
+                            if (typeof fieldSpec === "function") {
+                                (0, utils_js_1.exportNameHint)(fieldSpec, `${typeName}_${fieldName}_apply`);
+                                grafastExtensions.apply = fieldSpec;
+                            }
+                            else {
+                                const { apply, extensions } = fieldSpec;
+                                if (extensions) {
+                                    Object.assign(fieldConfig.extensions, extensions);
+                                }
+                                if (apply) {
+                                    (0, utils_js_1.exportNameHint)(fieldSpec.apply, `${typeName}_${fieldName}_apply`);
+                                    Object.assign(grafastExtensions, { apply });
+                                }
+                            }
                         }
-                        // it's a spec
-                        const grafastExtensions = Object.create(null);
-                        fieldConfig.extensions.grafast = grafastExtensions;
-                        Object.assign(grafastExtensions, fieldSpec);
                     }
                     return fields;
                 };
@@ -299,22 +330,26 @@ function makeGrafastSchema(details) {
                             continue;
                         }
                         if (typeof enumValueSpec === "function") {
-                            (0, utils_js_1.exportNameHint)(enumValueSpec, `${typeName}_${enumValueName}_applyPlan`);
+                            (0, utils_js_1.exportNameHint)(enumValueSpec, `${typeName}_${enumValueName}_apply`);
                             // It's a plan
                             if (!enumValue.extensions) {
                                 enumValue.extensions = Object.create(null);
                             }
                             enumValue.extensions.grafast = {
-                                applyPlan: enumValueSpec,
+                                apply: enumValueSpec,
                             };
                         }
                         else if (typeof enumValueSpec === "object" &&
                             enumValueSpec != null) {
                             // It's a full spec
-                            if (enumValueSpec.applyPlan) {
-                                (0, utils_js_1.exportNameHint)(enumValueSpec.applyPlan, `${typeName}_${enumValueName}_applyPlan`);
+                            if (enumValueSpec.extensions) {
+                                (0, utils_js_1.exportNameHint)(enumValueSpec.extensions, `${typeName}_${enumValueName}_extensions`);
+                                Object.assign(enumValue.extensions, enumValueSpec.extensions);
+                            }
+                            if (enumValueSpec.apply) {
+                                (0, utils_js_1.exportNameHint)(enumValueSpec.apply, `${typeName}_${enumValueName}_apply`);
                                 enumValue.extensions.grafast = {
-                                    applyPlan: enumValueSpec.applyPlan,
+                                    apply: enumValueSpec.apply,
                                 };
                             }
                             if ("value" in enumValueSpec) {
@@ -356,5 +391,4 @@ function makeGrafastSchema(details) {
     const schema = new graphql_1.GraphQLSchema(schemaConfig);
     return schema;
 }
-exports.makeGrafastSchema = makeGrafastSchema;
 //# sourceMappingURL=makeGrafastSchema.js.map

package/dist/mermaid.js

@@ -3,7 +3,8 @@
  * This file contains all our utilities for dealing with Mermaid-js
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.planToMermaid = exports.mermaidEscape = exports.COLORS = void 0;
+exports.mermaidEscape = exports.COLORS = void 0;
+exports.planToMermaid = planToMermaid;
 const tslib_1 = require("tslib");
 const stripAnsi_js_1 = require("./stripAnsi.js");
 /**
@@ -64,6 +65,9 @@ exports.mermaidEscape = mermaidEscape;
 function isGrafastPlanJSONv1(json) {
     return json.version === "v1";
 }
+function shouldHideStep(step) {
+    return step.extra?.constant?.type === "undefined";
+}
 function planToMermaid(planJSON, { 
 // printPathRelations = false,
 concise = false, skipBuckets = global.grafastExplainMermaidSkipBuckets ?? false, } = {}) {
@@ -125,6 +129,9 @@ concise = false, skipBuckets = global.grafastExplainMermaidSkipBuckets ?? false,
     const planIdMap = Object.create(null);
     const planId = (plan) => {
         if (!planIdMap[plan.id]) {
+            if (shouldHideStep(plan)) {
+                console.warn(`Was expecting to hide step ${plan.id}, but we're rendering it anyway?`);
+            }
             const planName = plan.stepClass.replace(/Step$/, "");
             const planNode = `${planName}${plan.id}`;
             planIdMap[plan.id] = planNode;
@@ -137,7 +144,7 @@ concise = false, skipBuckets = global.grafastExplainMermaidSkipBuckets ?? false,
                 pp(stepById[plan.dependencyIds[0]].polymorphicPaths) === polyPaths
                 ? ""
                 : `\n${polyPaths}`;
-            const planString = `${planName}[${plan.id}${`∈${plan.bucketId}`}]${plan.isUnary ? " ➊" : ""}${meta ? `\n<${meta}>` : ""}${polyPathsIfDifferent}`;
+            const planString = `${planName}[${plan.id}${`∈${plan.bucketId}`}${plan.stream ? "@s" : ""}]${plan.isUnary ? " ➊" : ""}${meta ? `\n<${meta}>` : ""}${polyPathsIfDifferent}`;
             const [lBrace, rBrace] = plan.stepClass === "__ItemStep"
                 ? ["[/", "\\]"]
                 : plan.isSyncAndSafe
@@ -188,10 +195,20 @@ concise = false, skipBuckets = global.grafastExplainMermaidSkipBuckets ?? false,
     sortedSteps.forEach(
     // This comment is here purely to maintain the previous formatting to reduce a git diff.
     (plan) => {
+        if (shouldHideStep(plan))
+            return;
         const planNode = planId(plan);
-        const depNodes = plan.dependencyIds.map((depId) => {
-            return planId(stepById[depId]);
-        });
+        const depNodes = plan.dependencyIds
+            .map((depId) => {
+            const step = stepById[depId];
+            if (shouldHideStep(step)) {
+                return null;
+            }
+            else {
+                return planId(step);
+            }
+        })
+            .filter((n) => n !== null);
         const transformItemPlanNode = null;
         /*
         plan.stepClass === '__ListTransformStep'
@@ -217,9 +234,7 @@ concise = false, skipBuckets = global.grafastExplainMermaidSkipBuckets ?? false,
                             normal.push(r);
                         }
                     }
-                    if (normal.length) {
-                        graph.push(`    ${normal.join(" & ")} --> ${planNode}`);
-                    }
+                    outputGroupedNormalLinks(graph, planNode, normal);
                 }
             }
             else {
@@ -248,9 +263,7 @@ concise = false, skipBuckets = global.grafastExplainMermaidSkipBuckets ?? false,
                             normal.push(r);
                         }
                     }
-                    if (normal.length) {
-                        graph.push(`    ${normal.join(" & ")} --> ${planNode}`);
-                    }
+                    outputGroupedNormalLinks(graph, planNode, normal);
                 }
             }
         }
@@ -262,7 +275,9 @@ concise = false, skipBuckets = global.grafastExplainMermaidSkipBuckets ?? false,
     graph.push("");
     graph.push("    %% define steps");
     sortedSteps.forEach((step) => {
-        planId(step);
+        if (!shouldHideStep(step)) {
+            planId(step);
+        }
     });
     const stepToString = (step) => {
         return `${step.stepClass.replace(/Step$/, "")}${step.bucketId === 0 ? "" : `{${step.bucketId}}`}${step.metaString ? `<${step.metaString}>` : ""}[${step.id}]`;
@@ -304,7 +319,10 @@ concise = false, skipBuckets = global.grafastExplainMermaidSkipBuckets ?? false,
                 : ""}${startSteps(layerPlan)}`)}):::bucket`);
         }
         graph.push(`    classDef bucket${layerPlan.id} stroke:${color(layerPlan.id)}`);
-        graph.push(`    class ${[`Bucket${layerPlan.id}`, ...steps.map(planId)].join(",")} bucket${layerPlan.id}`);
+        graph.push(`    class ${[
+            `Bucket${layerPlan.id}`,
+            ...steps.filter((s) => !shouldHideStep(s)).map(planId),
+        ].join(",")} bucket${layerPlan.id}`);
     }
     if (!skipBuckets) {
         for (let i = 0, l = layerPlans.length; i < l; i++) {
@@ -344,7 +362,6 @@ concise = false, skipBuckets = global.grafastExplainMermaidSkipBuckets ?? false,
                 .join("\n")}`;
     }
 }
-exports.planToMermaid = planToMermaid;
 function pp(polymorphicPaths) {
     if (!polymorphicPaths) {
         return "";
@@ -360,4 +377,26 @@ function trim(string, length = 15) {
         return string;
     }
 }
+function outputGroupedNormalLinks(graph, planNode, normal) {
+    if (normal.length) {
+        const counts = Object.create(null);
+        for (const n of normal) {
+            if (counts[n]) {
+                counts[n]++;
+            }
+            else {
+                counts[n] = 1;
+            }
+        }
+        const oners = Object.keys(counts).filter((n) => counts[n] === 1);
+        if (oners.length >= 1) {
+            graph.push(`    ${oners.join(" & ")} --> ${planNode}`);
+        }
+        for (const [n, c] of Object.entries(counts)) {
+            if (c !== 1) {
+                graph.push(`    ${n} -- ${c} --> ${planNode}`);
+            }
+        }
+    }
+}
 //# sourceMappingURL=mermaid.js.map

package/dist/middleware.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getGrafastMiddleware = void 0;
+exports.getGrafastMiddleware = getGrafastMiddleware;
 const graphile_config_1 = require("graphile-config");
 const $$middleware = Symbol("middleware");
 function getGrafastMiddleware(resolvedPreset) {
@@ -21,5 +21,4 @@ function getGrafastMiddleware(resolvedPreset) {
     }
     return middleware;
 }
-exports.getGrafastMiddleware = getGrafastMiddleware;
 //# sourceMappingURL=middleware.js.map

package/dist/multistep.d.ts

@@ -1,19 +1,19 @@
-import { ExecutableStep } from "./step.js";
+import { Step } from "./step.js";
 /**
  * When using this, always use `const`! Otherwise tuples will show up as arrays
  * and break things.
  */
-export type Multistep = null | undefined | ExecutableStep | readonly [...(readonly ExecutableStep[])] | Record<string, ExecutableStep>;
-export type UnwrapMultistep<TMultistepSpec extends Multistep> = TMultistepSpec extends null ? null : TMultistepSpec extends undefined ? undefined : TMultistepSpec extends ExecutableStep<infer U> ? U : TMultistepSpec extends readonly [...(readonly any[])] ? {
-    [index in keyof TMultistepSpec]: TMultistepSpec[index] extends ExecutableStep<infer V> ? V : never;
+export type Multistep = null | undefined | Step | readonly [...(readonly Step[])] | Record<string, Step>;
+export type UnwrapMultistep<TMultistepSpec extends Multistep> = TMultistepSpec extends null ? null : TMultistepSpec extends undefined ? undefined : TMultistepSpec extends Step<infer U> ? U : TMultistepSpec extends readonly [...(readonly any[])] ? {
+    [index in keyof TMultistepSpec]: TMultistepSpec[index] extends Step<infer V> ? V : never;
 } : {
-    [key in keyof TMultistepSpec]: TMultistepSpec[key] extends ExecutableStep<infer V> ? V : never;
+    [key in keyof TMultistepSpec]: TMultistepSpec[key] extends Step<infer V> ? V : never;
 };
 interface MultistepCacheConfig {
     identifier: string;
     cacheSize: number;
 }
-export declare function multistep<const TMultistepSpec extends Multistep>(spec: TMultistepSpec, stable?: string | true | MultistepCacheConfig): ExecutableStep<UnwrapMultistep<TMultistepSpec>>;
+export declare function multistep<const TMultistepSpec extends Multistep>(spec: TMultistepSpec, stable?: string | true | MultistepCacheConfig): Step<UnwrapMultistep<TMultistepSpec>>;
 export declare function isMultistep<const TMultistepSpec extends Multistep>(spec: any): spec is TMultistepSpec;
 export {};
 //# sourceMappingURL=multistep.d.ts.map

package/dist/multistep.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isMultistep = exports.multistep = void 0;
+exports.multistep = multistep;
+exports.isMultistep = isMultistep;
 const step_js_1 = require("./step.js");
 const constant_js_1 = require("./steps/constant.js");
 const list_js_1 = require("./steps/list.js");
@@ -10,7 +11,7 @@ function multistep(spec, stable) {
     if (spec == null) {
         return (0, constant_js_1.constant)(spec);
     }
-    else if (spec instanceof step_js_1.ExecutableStep) {
+    else if (spec instanceof step_js_1.Step) {
         return spec;
     }
     else if ((0, utils_js_1.isTuple)(spec)) {
@@ -32,24 +33,22 @@ function multistep(spec, stable) {
         return $step;
     }
 }
-exports.multistep = multistep;
 function isMultistep(spec) {
     if (spec == null) {
         return true;
     }
-    else if (spec instanceof step_js_1.ExecutableStep) {
+    else if (spec instanceof step_js_1.Step) {
         return true;
     }
-    else if ((0, utils_js_1.isTuple)(spec) && spec.every((s) => s instanceof step_js_1.ExecutableStep)) {
+    else if ((0, utils_js_1.isTuple)(spec) && spec.every((s) => s instanceof step_js_1.Step)) {
         return true;
     }
     else if (typeof spec === "object" &&
-        Object.values(spec).every((s) => s instanceof step_js_1.ExecutableStep)) {
+        Object.values(spec).every((s) => s instanceof step_js_1.Step)) {
         return true;
     }
     else {
         return false;
     }
 }
-exports.isMultistep = isMultistep;
 //# sourceMappingURL=multistep.js.map

package/dist/operationPlan-input.d.ts

@@ -1,7 +1,8 @@
-import type { GraphQLField } from "graphql";
+import type { GraphQLField, GraphQLInputType, GraphQLNullableType } from "graphql";
 import type { OperationPlan } from "./engine/OperationPlan.js";
 import type { FieldArgs, TrackedArguments } from "./interfaces.js";
-import type { ExecutableStep } from "./step.js";
-export type ApplyAfterModeArg = "autoApplyAfterParentPlan" | "autoApplyAfterParentSubscribePlan";
-export declare function withFieldArgsForArguments<T extends ExecutableStep, TParentStep extends ExecutableStep = ExecutableStep>(operationPlan: OperationPlan, $parent: TParentStep, $all: TrackedArguments, field: GraphQLField<any, any, any>, applyAfterMode: ApplyAfterModeArg, callback: (fieldArgs: FieldArgs) => T | null | undefined): Exclude<T, undefined | null> | null;
+import type { Step } from "./step.js";
+export type ApplyAfterModeArg = "plan" | "subscribePlan";
+export declare function withFieldArgsForArguments<T extends Step>(operationPlan: OperationPlan, $all: TrackedArguments, field: GraphQLField<any, any, any>, $parent: Step, applyAfterMode: ApplyAfterModeArg, coordinate: string, callback: (fieldArgs: FieldArgs) => T | null | undefined): Exclude<T, undefined | null> | null;
+export declare function getNullableInputTypeAtPath(startType: GraphQLInputType, path: ReadonlyArray<string | number>): GraphQLInputType & GraphQLNullableType;
 //# sourceMappingURL=operationPlan-input.d.ts.map