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

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}`}]${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
@@ -159,13 +166,49 @@ concise = false, skipBuckets = global.grafastExplainMermaidSkipBuckets ?? false,
     graph.push("");
     graph.push("    %% plan dependencies");
     const chainByDep = Object.create(null);
+    const depDeets = (step, idx) => {
+        const forbiddenFlags = step.dependencyForbiddenFlags[idx];
+        const onReject = step.dependencyOnReject[idx];
+        const info = [];
+        if (forbiddenFlags) {
+            if ((forbiddenFlags & 2) === 2) {
+                info.push("rejectNull");
+            }
+            if ((forbiddenFlags & 1) === 0) {
+                info.push("trapError");
+            }
+            if ((forbiddenFlags & 4) === 0) {
+                info.push("trapInhibited");
+            }
+            if (onReject) {
+                info.push(`onReject=${trim((0, stripAnsi_js_1.stripAnsi)(onReject))}`);
+            }
+        }
+        const str = info.join(";");
+        if (str) {
+            return `|${(0, exports.mermaidEscape)(str)}|`;
+        }
+        else {
+            return "";
+        }
+    };
     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'
@@ -178,9 +221,20 @@ concise = false, skipBuckets = global.grafastExplainMermaidSkipBuckets ?? false,
             if (plan.stepClass === "__ItemStep") {
                 const [firstDep, ...rest] = depNodes;
                 const arrow = plan.extra?.transformStepId == null ? "==>" : "-.->";
-                graph.push(`    ${firstDep} ${arrow} ${planNode}`);
+                graph.push(`    ${firstDep} ${arrow}${depDeets(plan, 0)} ${planNode}`);
                 if (rest.length > 0) {
-                    graph.push(`    ${rest.join(" & ")} --> ${planNode}`);
+                    const normal = [];
+                    for (let i = 0; i < rest.length; i++) {
+                        const r = rest[i];
+                        const deets = depDeets(plan, i + 1);
+                        if (deets) {
+                            graph.push(`    ${r} -->${deets} ${planNode}`);
+                        }
+                        else {
+                            normal.push(r);
+                        }
+                    }
+                    outputGroupedNormalLinks(graph, planNode, normal);
                 }
             }
             else {
@@ -190,15 +244,26 @@ concise = false, skipBuckets = global.grafastExplainMermaidSkipBuckets ?? false,
                     // Try alternating the nodes so they render closer together
                     const depNode = depNodes[0];
                     if (chainByDep[depNode] === undefined) {
-                        graph.push(`    ${depNode} --> ${planNode}`);
+                        graph.push(`    ${depNode} -->${depDeets(plan, 0)} ${planNode}`);
                     }
                     else {
-                        graph.push(`    ${chainByDep[depNode]} o--o ${planNode}`);
+                        graph.push(`    ${chainByDep[depNode]} o--o${depDeets(plan, 0)} ${planNode}`);
                     }
                     chainByDep[depNode] = planNode;
                 }
                 else {
-                    graph.push(`    ${depNodes.join(" & ")} --> ${planNode}`);
+                    const normal = [];
+                    for (let i = 0; i < depNodes.length; i++) {
+                        const r = depNodes[i];
+                        const deets = depDeets(plan, i + 1);
+                        if (deets) {
+                            graph.push(`    ${r} -->${deets} ${planNode}`);
+                        }
+                        else {
+                            normal.push(r);
+                        }
+                    }
+                    outputGroupedNormalLinks(graph, planNode, normal);
                 }
             }
         }
@@ -210,11 +275,25 @@ 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}]`;
     };
+    let firstSideEffect = true;
+    sortedSteps.forEach((step) => {
+        if (step.implicitSideEffectStepId) {
+            if (firstSideEffect) {
+                graph.push("");
+                graph.push("    %% implicit side effects");
+                firstSideEffect = false;
+            }
+            const sideEffectStep = stepById[step.implicitSideEffectStepId];
+            graph.push(`    ${planId(sideEffectStep)} -.-o ${planId(step)}`);
+        }
+    });
     graph.push("");
     if (!concise && !skipBuckets)
         graph.push("    subgraph Buckets");
@@ -226,20 +305,24 @@ concise = false, skipBuckets = global.grafastExplainMermaidSkipBuckets ?? false,
             (layerPlan.reason.type === "polymorphic"
                 ? `\n${layerPlan.reason.typeNames}`
                 : ``);
-        const outputMapStuff = [];
         if (!skipBuckets) {
-            graph.push(`    Bucket${layerPlan.id}(${(0, exports.mermaidEscape)(`Bucket ${layerPlan.id}${raisonDEtre}${layerPlan.copyStepIds.length > 0
+            graph.push(`    Bucket${layerPlan.id}(${(0, exports.mermaidEscape)(`Bucket ${layerPlan.id}${raisonDEtre}${layerPlan.parentSideEffectStepId != null
+                ? `\nParent side effect step: ${stepById[layerPlan.parentSideEffectStepId].id}`
+                : ""}${layerPlan.copyStepIds.length > 0
                 ? `\nDeps: ${layerPlan.copyStepIds
                     .map((pId) => stepById[pId].id)
-                    .join(", ")}\n`
+                    .join(", ")}`
                 : ""}${layerPlan.reason.type === "polymorphic"
-                ? pp(layerPlan.reason.polymorphicPaths)
-                : ""}${layerPlan.rootStepId != null && layerPlan.reason.type !== "root"
+                ? "\n" + pp(layerPlan.reason.polymorphicPaths)
+                : ""}\n${layerPlan.rootStepId != null && layerPlan.reason.type !== "root"
                 ? `\nROOT ${stepToString(stepById[layerPlan.rootStepId])}`
-                : ""}${startSteps(layerPlan)}\n${outputMapStuff.join("\n")}`)}):::bucket`);
+                : ""}${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++) {
@@ -279,7 +362,6 @@ concise = false, skipBuckets = global.grafastExplainMermaidSkipBuckets ?? false,
                 .join("\n")}`;
     }
 }
-exports.planToMermaid = planToMermaid;
 function pp(polymorphicPaths) {
     if (!polymorphicPaths) {
         return "";
@@ -287,4 +369,34 @@ function pp(polymorphicPaths) {
     return polymorphicPaths.map((p) => `${p}`).join("\n");
 }
 tslib_1.__exportStar(require("./planJSONInterfaces.js"), exports);
+function trim(string, length = 15) {
+    if (string.length > length) {
+        return string.substring(0, length - 2) + "…";
+    }
+    else {
+        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.d.ts

@@ -0,0 +1,7 @@
+import { Middleware } from "graphile-config";
+declare const $$middleware: unique symbol;
+export declare function getGrafastMiddleware(resolvedPreset: GraphileConfig.ResolvedPreset & {
+    [$$middleware]?: Middleware<GraphileConfig.GrafastMiddleware> | null;
+}): Middleware<GraphileConfig.GrafastMiddleware> | null;
+export {};
+//# sourceMappingURL=middleware.d.ts.map

package/dist/middleware.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGrafastMiddleware = getGrafastMiddleware;
+const graphile_config_1 = require("graphile-config");
+const $$middleware = Symbol("middleware");
+function getGrafastMiddleware(resolvedPreset) {
+    if (resolvedPreset[$$middleware] !== undefined) {
+        return resolvedPreset[$$middleware];
+    }
+    let middleware = null;
+    (0, graphile_config_1.orderedApply)(resolvedPreset.plugins, (p) => p.grafast?.middleware, (name, fn, _plugin) => {
+        if (!middleware)
+            middleware = new graphile_config_1.Middleware();
+        middleware.register(name, fn);
+    });
+    try {
+        resolvedPreset[$$middleware] = middleware;
+    }
+    catch {
+        // Ignore - preset must be readonly
+    }
+    return middleware;
+}
+//# sourceMappingURL=middleware.js.map

package/dist/multistep.d.ts

@@ -0,0 +1,19 @@
+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 | 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 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): 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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+const object_js_1 = require("./steps/object.js");
+const utils_js_1 = require("./utils.js");
+function multistep(spec, stable) {
+    if (spec == null) {
+        return (0, constant_js_1.constant)(spec);
+    }
+    else if (spec instanceof step_js_1.Step) {
+        return spec;
+    }
+    else if ((0, utils_js_1.isTuple)(spec)) {
+        const config = stable === true
+            ? { identifier: `multistep` }
+            : typeof stable === "string"
+                ? { identifier: stable }
+                : stable;
+        const $step = (0, list_js_1.list)(spec, config);
+        return $step;
+    }
+    else {
+        const config = stable === true
+            ? { identifier: `multistep` }
+            : typeof stable === "string"
+                ? { identifier: stable }
+                : stable;
+        const $step = (0, object_js_1.object)(spec, config);
+        return $step;
+    }
+}
+function isMultistep(spec) {
+    if (spec == null) {
+        return true;
+    }
+    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.Step)) {
+        return true;
+    }
+    else if (typeof spec === "object" &&
+        Object.values(spec).every((s) => s instanceof step_js_1.Step)) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+//# 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