grafast 0.1.1-beta.21 → 0.1.1-beta.22

package/dist/utils.js

@@ -7,6 +7,9 @@ exports.isPromise = isPromise;
 exports.isPromiseLike = isPromiseLike;
 exports.isDeferred = isDeferred;
 exports.arraysMatch = arraysMatch;
+exports.mapsMatch = mapsMatch;
+exports.recordsMatch = recordsMatch;
+exports.setsMatch = setsMatch;
 exports.objectSpec = objectSpec;
 exports.newObjectTypeBuilder = newObjectTypeBuilder;
 exports.objectFieldSpec = objectFieldSpec;
@@ -25,7 +28,11 @@ exports.sudo = sudo;
 exports.writeableArray = writeableArray;
 exports.stepADependsOnStepB = stepADependsOnStepB;
 exports.stepAMayDependOnStepB = stepAMayDependOnStepB;
+exports.stepAShouldTryAndInlineIntoStepB = stepAShouldTryAndInlineIntoStepB;
+exports.pathsFromAncestorToTargetLayerPlan = pathsFromAncestorToTargetLayerPlan;
+exports.layerPlanHeirarchyContains = layerPlanHeirarchyContains;
 exports.stepsAreInSamePhase = stepsAreInSamePhase;
+exports.isPhaseTransitionLayerPlan = isPhaseTransitionLayerPlan;
 exports.assertNotAsync = assertNotAsync;
 exports.assertNotPromise = assertNotPromise;
 exports.hasItemPlan = hasItemPlan;
@@ -246,7 +253,9 @@ function arraysMatch(array1, array2, comparator) {
     }
     if (comparator !== undefined) {
         for (let i = 0; i < l; i++) {
-            if (!comparator(array1[i], array2[i])) {
+            const a = array1[i];
+            const b = array2[i];
+            if (a !== b && !comparator(a, b)) {
                 return false;
             }
         }
@@ -260,19 +269,99 @@ function arraysMatch(array1, array2, comparator) {
     }
     return true;
 }
+/**
+ * Returns true if map1 and map2 have the same keys, and every matching entry
+ * value within them pass the `comparator` check (which defaults to `===`).
+ */
+function mapsMatch(map1, map2, comparator) {
+    if (map1 === map2)
+        return true;
+    const l = map1.size;
+    if (l !== map2.size) {
+        return false;
+    }
+    const allKeys = new Set([...map1.keys(), ...map2.keys()]);
+    if (allKeys.size !== l) {
+        return false;
+    }
+    if (comparator !== undefined) {
+        for (const k of allKeys) {
+            const a = map1.get(k);
+            const b = map2.get(k);
+            if (a !== b && !comparator(k, a, b)) {
+                return false;
+            }
+        }
+    }
+    else {
+        for (const k of allKeys) {
+            if (map1.get(k) !== map2.get(k)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+/**
+ * Returns true if record1 and record2 are equivalent, i.e. every value within
+ * them pass the `comparator` check (which defaults to `===`).
+ *
+ * Currently keys are ignored (`record[key] = undefined` is treated the same as
+ * `record[key]` being unset), but this may not always be the case.
+ */
+function recordsMatch(record1, record2, comparator) {
+    if (record1 === record2)
+        return true;
+    const k1 = Object.keys(record1);
+    const k2 = Object.keys(record2);
+    const allKeys = new Set([...k1, ...k2]);
+    if (comparator !== undefined) {
+        for (const k of allKeys) {
+            const a = record1[k];
+            const b = record2[k];
+            if (a !== b && !comparator(k, a, b)) {
+                return false;
+            }
+        }
+    }
+    else {
+        for (const k of allKeys) {
+            if (record1[k] !== record2[k]) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+function setsMatch(s1, s2) {
+    if (s1 === s2)
+        return true;
+    if (s1 == null)
+        return false;
+    if (s2 == null)
+        return false;
+    if (s1.size !== s2.size)
+        return false;
+    for (const p of s1) {
+        if (!s2.has(p))
+            return false;
+    }
+    return true;
+}
 /**
  * Saves us having to write `extensions: {grafast: {...}}` everywhere.
  */
 function objectSpec(spec) {
-    const { assertStep, ...rest } = spec;
+    const { assertStep, planType, ...rest } = spec;
     const modifiedSpec = {
         ...rest,
-        ...(assertStep
+        ...(assertStep || planType
             ? {
                 extensions: {
                     ...spec.extensions,
                     grafast: {
-                        assertStep,
+                        ...(assertStep ? { assertStep } : null),
+                        ...(planType ? { planType } : null),
                         ...spec.extensions?.grafast,
                     },
                 },
@@ -648,6 +737,9 @@ function stepADependsOnStepB(stepA, stepB) {
     }
     return false;
 }
+function stepAIsOrDependsOnStepB(stepA, stepB) {
+    return stepA === stepB || stepADependsOnStepB(stepA, stepB);
+}
 /**
  * Returns true if stepA is allowed to depend on stepB, false otherwise. (This
  * mostly relates to heirarchy.)
@@ -664,6 +756,80 @@ function stepAMayDependOnStepB($a, $b) {
     }
     return !stepADependsOnStepB($b, $a);
 }
+function stepAShouldTryAndInlineIntoStepB($a, $b) {
+    if (dev_js_1.isDev && !stepADependsOnStepB($a, $b)) {
+        throw new Error(`Shouldn't try and inline into something you're not dependent on!`);
+    }
+    if (!stepsAreInSamePhase($b, $a))
+        return false;
+    // TODO: review the rules about polymorphism here; e.g. "only if most of the
+    // polymorphic paths are covered" or something. We don't want the parent to
+    // do lots of work for lots of polymorphic paths that won't be covered, but
+    // equally we don't want to necessarily require 100% of the polymorphic
+    // branches to be matched.
+    const paths = pathsFromAncestorToTargetLayerPlan($b.layerPlan, $a.layerPlan);
+    let path;
+    if (paths.length === 0) {
+        throw new Error(`No path from ${$a} back to ${$b}?`);
+    }
+    else if (paths.length > 1) {
+        const commonPath = [];
+        const firstPath = paths[0];
+        for (const lp of firstPath) {
+            if (paths.every((p) => p.includes(lp))) {
+                commonPath.push(lp);
+            }
+        }
+        path = commonPath;
+    }
+    else {
+        path = paths[0];
+    }
+    for (const lp of path) {
+        if (lp.reason.type === "polymorphicPartition") {
+            return false;
+        }
+    }
+    return true;
+}
+function pathsFromAncestorToTargetLayerPlan(ancestor, lp) {
+    if (lp === ancestor) {
+        // One path, and it's the null path - stay where you are.
+        return [[]];
+    }
+    if (lp.reason.type === "root") {
+        // No paths found - lp doesn't inherit from ancestor.
+        return [];
+    }
+    else if (lp.reason.type === "combined") {
+        const childPaths = lp.reason.parentLayerPlans.flatMap((plp) => pathsFromAncestorToTargetLayerPlan(ancestor, plp));
+        for (const path of childPaths) {
+            path.push(lp);
+        }
+        return childPaths;
+    }
+    else {
+        const childPaths = pathsFromAncestorToTargetLayerPlan(ancestor, lp.reason.parentLayerPlan);
+        for (const path of childPaths) {
+            path.push(lp);
+        }
+        return childPaths;
+    }
+}
+function layerPlanHeirarchyContains(lp, targetLp) {
+    if (lp === targetLp)
+        return true;
+    if (lp.reason.type === "root") {
+        return false;
+    }
+    else if (lp.reason.type === "combined") {
+        return lp.reason.parentLayerPlans.some((plp) => layerPlanHeirarchyContains(plp, targetLp));
+    }
+    else {
+        // PERF: loop would be faster than recursion
+        return layerPlanHeirarchyContains(lp.reason.parentLayerPlan, targetLp);
+    }
+}
 /**
  * For a regular GraphQL query with no `@stream`/`@defer`, the entire result is
  * calculated and then the output is generated and sent to the client at once.
@@ -692,24 +858,46 @@ function stepAMayDependOnStepB($a, $b) {
  * need it.
  */
 function stepsAreInSamePhase(ancestor, descendent) {
-    let currentLayerPlan = descendent.layerPlan;
-    do {
-        if (currentLayerPlan === ancestor.layerPlan) {
-            return true;
+    if (dev_js_1.isDev && !stepADependsOnStepB(descendent, ancestor)) {
+        throw new Error(`Shouldn't try and inline into something you're not dependent on!`);
+    }
+    const ancestorDepth = ancestor.layerPlan.depth;
+    const descendentDepth = descendent.layerPlan.depth;
+    if (descendentDepth < ancestorDepth) {
+        throw new Error(`descendent is deeper than ancestor; did you pass ancestor/descendent the wrong way around?`);
+    }
+    const descDeferBoundary = descendent.layerPlan.ancestry[descendent.layerPlan.deferBoundaryDepth];
+    if (ancestor.layerPlan.ancestry[ancestor.layerPlan.deferBoundaryDepth] !==
+        descDeferBoundary) {
+        // Still possible to be okay if ancestor is the source of a streamed list item or deferred step
+        if (descDeferBoundary.reason.type === "listItem" &&
+            descDeferBoundary.reason.stream != null &&
+            descendent.layerPlan.ancestry[descendent.layerPlan.deferBoundaryDepth - 1] === ancestor.layerPlan) {
+            if (stepAIsOrDependsOnStepB(descDeferBoundary.reason.parentStep, ancestor)) {
+                return true;
+            }
+        }
+        // Nope, don't allow
+        return false;
+    }
+    for (let i = 0; i < ancestorDepth; i++) {
+        if (ancestor.layerPlan.ancestry[i] !== descendent.layerPlan.ancestry[i]) {
+            return false;
         }
+    }
+    for (let i = ancestorDepth + 1; i < descendentDepth; i++) {
+        const currentLayerPlan = descendent.layerPlan.ancestry[i];
         const t = currentLayerPlan.reason.type;
         switch (t) {
+            case "combined": {
+                continue;
+            }
             case "subscription":
             case "defer": {
                 // These indicate boundaries over which plans shouldn't be optimized
                 // together (generally).
                 return false;
             }
-            case "polymorphic": {
-                // OPTIMIZE: can optimize this so that if all polymorphicPaths match then it
-                // passes
-                return false;
-            }
             case "listItem": {
                 if (currentLayerPlan.reason.stream) {
                     // It's streamed, but we can still inline the step into its parent since its the parent that is being streamed (so it should not add to the initial execution overhead).
@@ -723,6 +911,8 @@ function stepsAreInSamePhase(ancestor, descendent) {
             case "root":
             case "nullableBoundary":
             case "subroutine":
+            case "polymorphic":
+            case "polymorphicPartition":
             case "mutationField": {
                 continue;
             }
@@ -731,8 +921,38 @@ function stepsAreInSamePhase(ancestor, descendent) {
                 throw new Error(`Unhandled layer plan type '${never}'`);
             }
         }
-    } while ((currentLayerPlan = currentLayerPlan.parentLayerPlan));
-    throw new Error(`${descendent} is not dependent on ${ancestor}, perhaps you passed the arguments in the wrong order?`);
+    }
+    return true;
+}
+function isPhaseTransitionLayerPlan(layerPlan) {
+    const t = layerPlan.reason.type;
+    switch (t) {
+        case "subscription":
+        case "defer": {
+            return true;
+        }
+        case "listItem": {
+            if (layerPlan.reason.stream) {
+                return true;
+            }
+            else {
+                return false;
+            }
+        }
+        case "polymorphic":
+        case "polymorphicPartition":
+        case "root":
+        case "nullableBoundary":
+        case "subroutine":
+        case "combined": // TODO: CHECK ME!
+        case "mutationField": {
+            return false;
+        }
+        default: {
+            const never = t;
+            throw new Error(`Unhandled layer plan type '${never}'`);
+        }
+    }
 }
 // ENHANCE: implement this!
 const canonicalJSONStringify = (o) => JSON.stringify(o);

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "0.1.1-beta.21";
+export declare const version = "0.1.1-beta.22";
 //# sourceMappingURL=version.d.ts.map

package/dist/version.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = void 0;
 // This file is autogenerated by /scripts/postversion.mjs
-exports.version = "0.1.1-beta.21";
+exports.version = "0.1.1-beta.22";
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grafast",
-  "version": "0.1.1-beta.21",
+  "version": "0.1.1-beta.22",
   "description": "Cutting edge GraphQL planning and execution engine",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -55,20 +55,20 @@
     "node": ">=14.17"
   },
   "dependencies": {
-    "@graphile/lru": "^5.0.0-beta.3",
+    "@graphile/lru": "^5.0.0-beta.4",
     "chalk": "^4.1.2",
     "debug": "^4.3.4",
     "eventemitter3": "^5.0.1",
-    "graphile-config": "^0.0.1-beta.15",
+    "graphile-config": "^0.0.1-beta.16",
     "graphql": "^16.1.0-experimental-stream-defer.6",
     "iterall": "^1.3.0",
-    "tamedevil": "^0.0.0-beta.7",
-    "tslib": "^2.6.2"
+    "tamedevil": "^0.0.0-beta.8",
+    "tslib": "^2.8.1"
   },
   "peerDependencies": {
     "@envelop/core": "^5.0.0",
     "graphql": "^16.1.0-experimental-stream-defer.6",
-    "tamedevil": "^0.0.0-beta.7"
+    "tamedevil": "^0.0.0-beta.8"
   },
   "peerDependenciesMeta": {
     "@envelop/core": {

package/dist/polymorphic.d.ts

@@ -1,14 +0,0 @@
-import type { PolymorphicData } from "./interfaces.js";
-export declare function isPolymorphicData(data: unknown): data is PolymorphicData;
-export declare function assertPolymorphicData(data: unknown): asserts data is PolymorphicData;
-/**
- * Returns an object with the given concrete type (and, optionally, associated
- * data)
- */
-export declare function polymorphicWrap<TType extends string, TData>(type: TType, data?: TData): PolymorphicData<TType, TData>;
-/**
- * All polymorphic objects in Grafast have a $$concreteType property which
- * contains the GraphQL object's type name; we simply return that.
- */
-export declare function resolveType(o: unknown): string;
-//# sourceMappingURL=polymorphic.d.ts.map

package/dist/polymorphic.js

@@ -1,72 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isPolymorphicData = isPolymorphicData;
-exports.assertPolymorphicData = assertPolymorphicData;
-exports.polymorphicWrap = polymorphicWrap;
-exports.resolveType = resolveType;
-const inspect_js_1 = require("./inspect.js");
-const interfaces_js_1 = require("./interfaces.js");
-function isPolymorphicData(data) {
-    if (typeof data !== "object" || data === null) {
-        return false;
-    }
-    if (typeof data[interfaces_js_1.$$concreteType] !== "string") {
-        return false;
-    }
-    return true;
-}
-function assertPolymorphicData(data) {
-    if (!isPolymorphicData(data)) {
-        throw new Error(`Expected a polymorphic object, received ${(0, inspect_js_1.inspect)(data)}`);
-    }
-}
-// const EMPTY_OBJECT = Object.freeze(Object.create(null));
-/**
- * Returns an object with the given concrete type (and, optionally, associated
- * data)
- */
-function polymorphicWrap(type, 
-// TODO: when we stop mutating `data` we can replace this with `EMPTY_OBJECT`
-data = Object.create(null)) {
-    // ENHANCE: validate type further, e.g. that it's a valid object type
-    if (typeof type !== "string") {
-        throw new Error(`Expected a GraphQLObjectType name, but received ${(0, inspect_js_1.inspect)(type)}`);
-    }
-    if (data == null) {
-        throw new Error(`polymorphicWrap mustn't receive null-like data`);
-    }
-    Object.defineProperty(data, interfaces_js_1.$$concreteType, {
-        value: type,
-        enumerable: false,
-        writable: false,
-        configurable: false,
-    });
-    // TODO: should NOT mutate `data`, instead use a wrapper object and rewire
-    // through the pipeline.
-    return data;
-    /*
-    return Object.assign(Object.create(null), {
-      [$$concreteType]: type,
-      [$$data]: data,
-    });
-    */
-}
-/**
- * All polymorphic objects in Grafast have a $$concreteType property which
- * contains the GraphQL object's type name; we simply return that.
- */
-function resolveType(o) {
-    assertPolymorphicData(o);
-    return o[interfaces_js_1.$$concreteType];
-}
-/* TODO: we should be extracting data from a subproperty when we rewrite how polymorphism works.
-/* *
- * All polymorphic objects in Grafast have a $$concreteType property which
- * contains the GraphQL object's type name; we simply return that.
- * /
-export function resolveData(o: unknown): string {
-  assertPolymorphicData(o);
-  return o[$$data];
-}
-*/
-//# sourceMappingURL=polymorphic.js.map

package/dist/steps/polymorphicBranch.d.ts

@@ -1,27 +0,0 @@
-import type { GraphQLObjectType } from "graphql";
-import type { ExecutionDetails, GrafastResultsList, PromiseOrDirect } from "../index.js";
-import type { PolymorphicStep } from "../step.js";
-import { Step } from "../step.js";
-type StepData<TStep extends Step> = TStep extends Step<infer U> ? U : any;
-export interface PolymorphicBranchMatchers<TStep extends Step> {
-    [typeName: string]: PolymorphicBranchMatcher<TStep>;
-}
-export interface PolymorphicBranchMatcher<TStep extends Step> {
-    match?: (obj: StepData<TStep>) => boolean;
-    plan?: ($obj: TStep) => Step;
-}
-export declare class PolymorphicBranchStep<TStep extends Step> extends Step implements PolymorphicStep {
-    static $$export: {
-        moduleName: string;
-        exportName: string;
-    };
-    isSyncAndSafe: boolean;
-    private typeNames;
-    private matchers;
-    constructor($step: TStep, matchers: PolymorphicBranchMatchers<TStep>);
-    planForType(objectType: GraphQLObjectType): Step;
-    execute({ indexMap, values: [values0], }: ExecutionDetails): PromiseOrDirect<GrafastResultsList<any>>;
-}
-export declare function polymorphicBranch<TStep extends Step>($step: TStep, matchers: PolymorphicBranchMatchers<TStep>): PolymorphicBranchStep<TStep>;
-export {};
-//# sourceMappingURL=polymorphicBranch.d.ts.map

package/dist/steps/polymorphicBranch.js

@@ -1,62 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PolymorphicBranchStep = void 0;
-exports.polymorphicBranch = polymorphicBranch;
-const index_js_1 = require("../index.js");
-const step_js_1 = require("../step.js");
-const constant_js_1 = require("./constant.js");
-class PolymorphicBranchStep extends step_js_1.Step {
-    static { this.$$export = {
-        moduleName: "grafast",
-        exportName: "PolymorphicBranchStep",
-    }; }
-    constructor($step, matchers) {
-        super();
-        this.isSyncAndSafe = true;
-        this.addDependency($step);
-        this.typeNames = Object.keys(matchers);
-        this.matchers = Object.fromEntries(Object.entries(matchers).map(([typeName, matcher]) => {
-            const fixedMatcher = {
-                match: matcher.match ?? ((obj) => obj.__typename === typeName),
-                plan: matcher.plan ?? (($obj) => $obj),
-            };
-            return [typeName, fixedMatcher];
-        }));
-    }
-    planForType(objectType) {
-        const matcher = this.matchers[objectType.name];
-        const $step = this.getDep(0, true);
-        if (matcher) {
-            if (typeof matcher.plan === "function") {
-                return matcher.plan($step);
-            }
-            else {
-                return $step;
-            }
-        }
-        else {
-            // TODO: should this be an error?
-            return (0, constant_js_1.constant)(null);
-        }
-    }
-    execute({ indexMap, values: [values0], }) {
-        return indexMap((i) => {
-            const obj = values0.at(i);
-            let match = null;
-            if (obj != null) {
-                for (const typeName of this.typeNames) {
-                    if (this.matchers[typeName].match(obj)) {
-                        match = typeName;
-                        break;
-                    }
-                }
-            }
-            return match !== null ? (0, index_js_1.polymorphicWrap)(match, obj) : null;
-        });
-    }
-}
-exports.PolymorphicBranchStep = PolymorphicBranchStep;
-function polymorphicBranch($step, matchers) {
-    return new PolymorphicBranchStep($step, matchers);
-}
-//# sourceMappingURL=polymorphicBranch.js.map