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

package/dist/steps/applyInput.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Modifier = exports.ApplyInputStep = void 0;
+exports.inputArgsApply = inputArgsApply;
+exports.applyInput = applyInput;
+exports.isModifier = isModifier;
+exports.assertModifier = assertModifier;
+exports.isApplyableStep = isApplyableStep;
+const graphql_1 = require("graphql");
+const step_js_1 = require("../step.js");
+const index_js_1 = require("./index.js");
+let currentModifiers = [];
+let applyingModifiers = false;
+let inputArgsApplyDepth = 0;
+class ApplyInputStep extends step_js_1.UnbatchedStep {
+    static { this.$$export = {
+        moduleName: "grafast",
+        exportName: "ApplyInputStep",
+    }; }
+    constructor(inputType, $value, getTargetFromParent) {
+        super();
+        this.inputType = inputType;
+        this.getTargetFromParent = getTargetFromParent;
+        this.isSyncAndSafe = true;
+        this.allowMultipleOptimizations = true;
+        this.valueDepId = this.addUnaryDependency($value);
+        if (!this._isUnary) {
+            throw new Error(`applyInput() must be unary`);
+        }
+        this._isUnaryLocked = true;
+    }
+    deduplicate(peers) {
+        return peers.filter((p) => p.inputType === this.inputType &&
+            p.getTargetFromParent === this.getTargetFromParent);
+    }
+    optimize() {
+        const $value = this.getDep(this.valueDepId);
+        if ($value instanceof index_js_1.ConstantStep) {
+            // Replace myself with a constant!
+            const { operationPlan: { schema }, inputType, getTargetFromParent, } = this;
+            const { data } = $value;
+            return (0, index_js_1.constant)(function applyInputConstant(parent) {
+                inputArgsApply(schema, inputType, parent, data, getTargetFromParent);
+            }, false);
+        }
+        return this;
+    }
+    unbatchedExecute(extra, value) {
+        const { getTargetFromParent } = this;
+        return (parentThing) => inputArgsApply(this.operationPlan.schema, this.inputType, parentThing, value, getTargetFromParent);
+    }
+}
+exports.ApplyInputStep = ApplyInputStep;
+function inputArgsApply(schema, inputType, parent, inputValue, getTargetFromParent) {
+    try {
+        inputArgsApplyDepth++;
+        const target = getTargetFromParent
+            ? getTargetFromParent(parent, inputValue)
+            : parent;
+        if (target != null) {
+            _inputArgsApply(schema, inputType, target, inputValue);
+        }
+    }
+    finally {
+        inputArgsApplyDepth--;
+    }
+    let l;
+    if (inputArgsApplyDepth === 0 && (l = currentModifiers.length) > 0) {
+        applyingModifiers = true;
+        try {
+            for (let i = l - 1; i >= 0; i--) {
+                currentModifiers[i].apply();
+            }
+        }
+        finally {
+            applyingModifiers = false;
+            currentModifiers = [];
+        }
+    }
+}
+function applyInput(inputType, $value, getTargetFromParent) {
+    const opPlan = (0, index_js_1.operationPlan)();
+    const { schema } = opPlan;
+    return opPlan.withRootLayerPlan(() => {
+        if ($value instanceof index_js_1.ConstantStep) {
+            // Replace us with a constant
+            const { data } = $value;
+            return (0, index_js_1.constant)(function applyInputConstant(parent) {
+                inputArgsApply(schema, inputType, parent, data, getTargetFromParent);
+            }, false);
+        }
+        else {
+            return new ApplyInputStep(inputType, $value, getTargetFromParent);
+        }
+    });
+}
+/*
+const defaultInputObjectTypeInputPlanResolver: InputObjectTypeInputPlanResolver =
+  (input, info) => {
+    const fields = info.type.getFields();
+    const obj: { [key: string]: ExecutableStep } = Object.create(null);
+    for (const fieldName in fields) {
+      obj[fieldName] = input.get(fieldName);
+    }
+    return object(obj);
+  };
+*/
+function _inputArgsApply(schema, inputType, target, inputValue) {
+    // PERF: we should have the plan generate a digest of `inputType` so that we
+    // can jump right to the relevant parts without too much traversal cost.
+    if (inputValue === undefined) {
+        return;
+    }
+    if ((0, graphql_1.isNonNullType)(inputType)) {
+        if (inputValue === null) {
+            throw new Error(`null value found in non-null position`);
+        }
+        _inputArgsApply(schema, inputType.ofType, target, inputValue);
+    }
+    else if ((0, graphql_1.isListType)(inputType)) {
+        if (inputValue == null)
+            return;
+        if (!Array.isArray(inputValue)) {
+            throw new Error(`Expected list in list position`);
+        }
+        for (const item of inputValue) {
+            const itemTarget = typeof target === "function" ? target() : target;
+            _inputArgsApply(schema, inputType.ofType, itemTarget, item);
+        }
+    }
+    else if (typeof target === "function") {
+        throw new Error("Functions may only be used as the target for list types (the function is called once per list item)");
+    }
+    else if ((0, graphql_1.isInputObjectType)(inputType)) {
+        if (inputValue === null) {
+            return;
+        }
+        const fields = inputType.getFields();
+        for (const [fieldName, field] of Object.entries(fields)) {
+            const val = inputValue[fieldName];
+            if (val === undefined)
+                continue;
+            if (field.extensions.grafast?.apply) {
+                const newTarget = field.extensions.grafast.apply(target, val, {
+                    schema,
+                    field,
+                    fieldName,
+                });
+                if (newTarget != null) {
+                    _inputArgsApply(schema, field.type, newTarget, val);
+                }
+            }
+        }
+    }
+    else if ((0, graphql_1.isScalarType)(inputType)) {
+        // if (inputType.extensions.grafast?.apply) {
+        // }
+    }
+    else if ((0, graphql_1.isEnumType)(inputType)) {
+        if (inputValue === null) {
+            return;
+        }
+        const values = inputType.getValues();
+        const value = values.find((v) => v.value === inputValue);
+        if (value) {
+            if (value.extensions.grafast?.apply) {
+                value.extensions.grafast.apply(target);
+            }
+        }
+        else {
+            throw new Error(`Couldn't find value in ${inputType} for ${inputValue}`);
+        }
+    }
+    else {
+        const never = inputType;
+        throw new Error(`Input type expected, but found ${never}`);
+    }
+}
+/**
+ * Modifiers modify their parent (which may be another modifier or anything
+ * else). First they gather all the requirements from their children (if any)
+ * being applied to them, then they apply themselves to their parent. This
+ * application is done through the `apply()` method.
+ */
+class Modifier {
+    constructor(parent) {
+        this.parent = parent;
+        if (applyingModifiers) {
+            throw new Error(`Must not create new modifier whilst modifiers are being applied!`);
+        }
+        currentModifiers.push(this);
+    }
+}
+exports.Modifier = Modifier;
+function isModifier(plan) {
+    return plan instanceof Modifier;
+}
+function assertModifier(plan, pathDescription) {
+    if (!isModifier(plan)) {
+        throw new Error(`The plan returned from '${pathDescription}' should be a modifier plan, but it does not implement the 'apply' method.`);
+    }
+}
+function isApplyableStep(s) {
+    return typeof s.apply === "function";
+}
+//# sourceMappingURL=applyInput.js.map

package/dist/steps/applyTransforms.d.ts

@@ -1,32 +1,9 @@
-import type { LayerPlanReasonSubroutine } from "../engine/LayerPlan.js";
-import { LayerPlan } from "../engine/LayerPlan.js";
-import type { GrafastError } from "../error.js";
-import type { ExecutionExtra, GrafastResultsList, GrafastValuesList } from "../interfaces.js";
-import type { ListCapableStep } from "../step.js";
-import { ExecutableStep } from "../step.js";
-/**
- * @internal
- */
-export declare class ApplyTransformsStep extends ExecutableStep {
-    static $$export: {
-        moduleName: string;
-        exportName: string;
-    };
-    isSyncAndSafe: boolean;
-    /** Set during query planning.  */
-    itemStepId: number;
-    /**
-     * @internal
-     */
-    subroutineLayer: LayerPlan<LayerPlanReasonSubroutine>;
-    constructor(listPlan: ListCapableStep<any, any>);
-    execute(_count: number, values: [GrafastValuesList<any[] | null | undefined | GrafastError>], extra: ExecutionExtra): Promise<GrafastResultsList<any[]>>;
-}
+import { Step } from "../step.js";
 /**
  * If you want to use a step that might represent a list and you need all of
  * the `listItem` transforms to have already taken place (e.g. you're going to
  * send the result to an external service) rather than processing them through
  * the GraphQL response, then you may need to call `applyTransforms` on it.
  */
-export declare function applyTransforms($step: ExecutableStep): ExecutableStep<any>;
+export declare function applyTransforms($step: Step): Step<any>;
 //# sourceMappingURL=applyTransforms.d.ts.map

package/dist/steps/applyTransforms.js

@@ -1,26 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyTransforms = exports.ApplyTransformsStep = void 0;
+exports.ApplyTransformsStep = void 0;
+exports.applyTransforms = applyTransforms;
 const tslib_1 = require("tslib");
 const assert = tslib_1.__importStar(require("../assert.js"));
 const dev_js_1 = require("../dev.js");
 const executeBucket_js_1 = require("../engine/executeBucket.js");
 const LayerPlan_js_1 = require("../engine/LayerPlan.js");
 const withGlobalLayerPlan_js_1 = require("../engine/lib/withGlobalLayerPlan.js");
+const error_js_1 = require("../error.js");
+const interfaces_js_1 = require("../interfaces.js");
 const step_js_1 = require("../step.js");
 const __item_js_1 = require("./__item.js");
+const connection_js_1 = require("./connection.js");
 /**
  * @internal
  */
-class ApplyTransformsStep extends step_js_1.ExecutableStep {
+class ApplyTransformsStep extends step_js_1.Step {
     static { this.$$export = {
         moduleName: "grafast",
         exportName: "ApplyTransformsStep",
     }; }
-    constructor(listPlan) {
+    constructor($step) {
         super();
         // OPTIMIZE: if all the steps in the inner bucket are synchronous then theoretically we can be synchronous too
         this.isSyncAndSafe = false;
+        const listPlan = (0, connection_js_1.itemsOrStep)($step);
         this.addDependency(listPlan);
         // Plan this subroutine
         this.subroutineLayer = new LayerPlan_js_1.LayerPlan(this.operationPlan, this.layerPlan, {
@@ -47,33 +52,44 @@ class ApplyTransformsStep extends step_js_1.ExecutableStep {
         this.subroutineLayer.setRootStep(itemPlan);
         this.operationPlan.finishSubroutine(this, this.subroutineLayer);
     }
-    async execute(_count, values, extra) {
+    async execute({ indexMap, values: [values0], extra, }) {
         const bucket = extra._bucket;
         const childLayerPlan = this.subroutineLayer;
-        const copyStepIds = childLayerPlan.copyStepIds;
+        const { copyStepIds, rootStep } = childLayerPlan;
         const store = new Map();
         const polymorphicPathList = [];
         const iterators = [];
         const map = new Map();
         let size = 0;
         // ENHANCE: do this better!
-        const itemStepId = this.operationPlan.dangerouslyGetStep(this.itemStepId).id;
+        const itemStep = this.operationPlan.dangerouslyGetStep(this.itemStepId);
+        const itemStepId = itemStep.id;
         if (itemStepId == null) {
             throw new Error("GrafastInternalError<b3a2bff9-15c6-47e2-aa82-19c862324f1a>: listItem layer plan has no rootStepId");
         }
-        store.set(itemStepId, []);
-        // Prepare store with an empty list for each copyPlanId
-        for (const planId of copyStepIds) {
-            store.set(planId, []);
-            if (!bucket.store.has(planId)) {
-                throw new Error(`GrafastInternalError<14f2b4c6-f951-44d6-ad6b-2eace3330b84>: plan '${planId}' (${this.operationPlan.dangerouslyGetStep(planId)}) listed in copyStepIds but not available in parent bucket for ${this}`);
+        if (itemStep._isUnary) {
+            store.set(itemStepId, (0, executeBucket_js_1.unaryExecutionValue)(values0.unaryValue()));
+        }
+        else {
+            store.set(itemStepId, (0, executeBucket_js_1.batchExecutionValue)([]));
+        }
+        for (const stepId of copyStepIds) {
+            const ev = bucket.store.get(stepId);
+            if (!ev) {
+                throw new Error(`GrafastInternalError<68675bbd-bc15-4c4a-902a-61c0de616325>: unary step '${stepId}' (${this.operationPlan.dangerouslyGetStep(stepId)}) listed in copyStepIds but not available in parent bucket for ${this}`);
+            }
+            if (ev.isBatch) {
+                // Prepare store with an empty list for each copyBatchPlanId
+                store.set(stepId, (0, executeBucket_js_1.batchExecutionValue)([]));
+            }
+            else {
+                store.set(stepId, ev);
             }
         }
-        const listValues = values[0];
         // We'll typically be creating more listItem bucket entries than we
         // have parent buckets, so we must "multiply up" the store entries.
-        for (let originalIndex = 0; originalIndex < listValues.length; originalIndex++) {
-            const list = listValues[originalIndex];
+        indexMap((originalIndex) => {
+            const list = values0.at(originalIndex);
             if (Array.isArray(list)) {
                 const newIndexes = [];
                 map.set(originalIndex, newIndexes);
@@ -85,40 +101,47 @@ class ApplyTransformsStep extends step_js_1.ExecutableStep {
                     // Copying across the iterators because we do NOT call outputBucket,
                     // so we need to ensure any streams are cleaned up.
                     iterators[newIndex] = bucket.iterators[originalIndex];
-                    store.get(itemStepId)[newIndex] = list[j];
-                    for (const planId of copyStepIds) {
-                        store.get(planId)[newIndex] =
-                            bucket.store.get(planId)[originalIndex];
+                    const ev = store.get(itemStepId);
+                    if (ev.isBatch) {
+                        // TODO: check for error?
+                        ev._setResult(newIndex, list[j], 0);
+                    }
+                    for (const copyStepId of copyStepIds) {
+                        const ev = store.get(copyStepId);
+                        if (ev.isBatch) {
+                            const orig = bucket.store.get(copyStepId);
+                            ev._setResult(newIndex, orig.at(originalIndex), orig._flagsAt(originalIndex));
+                        }
                     }
                 }
             }
-        }
+        });
         if (size > 0) {
             const childBucket = (0, executeBucket_js_1.newBucket)({
                 layerPlan: childLayerPlan,
                 size,
                 store,
-                hasErrors: bucket.hasErrors,
+                flagUnion: bucket.flagUnion,
                 polymorphicPathList,
                 iterators,
             }, bucket.metaByMetaKey);
             await (0, executeBucket_js_1.executeBucket)(childBucket, extra._requestContext);
         }
-        const depResults = store.get(childLayerPlan.rootStep.id);
-        return listValues.map((list, originalIndex) => {
+        const depResults = store.get(rootStep.id);
+        return indexMap((originalIndex) => {
+            const list = values0.at(originalIndex);
             if (list == null) {
                 return list;
             }
             const indexes = map.get(originalIndex);
             if (!Array.isArray(list) || !Array.isArray(indexes)) {
-                // ERRORS: should this be an error?
-                console.warn(`Either list or values was not an array when processing ${this}`);
-                return null;
+                // Not a list value; just pass it straight through
+                return list;
             }
             const values = indexes.map((idx) => {
-                const val = depResults[idx];
-                if (val instanceof Error) {
-                    throw val;
+                const val = depResults.at(idx);
+                if (depResults._flagsAt(idx) & interfaces_js_1.FLAG_ERROR) {
+                    return (0, error_js_1.flagError)(val);
                 }
                 return val;
             });
@@ -140,12 +163,11 @@ exports.ApplyTransformsStep = ApplyTransformsStep;
  */
 function applyTransforms($step) {
     if ((0, step_js_1.isListCapableStep)($step)) {
-        return new ApplyTransformsStep($step);
+        return $step.operationPlan.cacheStep($step, "GrafastInternal:applyTransforms()", "", () => new ApplyTransformsStep($step));
     }
     else {
         // No eval necessary
         return $step;
     }
 }
-exports.applyTransforms = applyTransforms;
 //# sourceMappingURL=applyTransforms.js.map

package/dist/steps/bakedInput.d.ts

@@ -0,0 +1,23 @@
+import type { GraphQLInputObjectType, GraphQLInputType, GraphQLList, GraphQLSchema } from "graphql";
+import type { UnbatchedExecutionExtra } from "../interfaces.js";
+import type { Step } from "../step.js";
+import { UnbatchedStep } from "../step.js";
+export declare class BakedInputStep<TData = any> extends UnbatchedStep<TData> {
+    private inputType;
+    static $$export: {
+        moduleName: string;
+        exportName: string;
+    };
+    isSyncAndSafe: boolean;
+    valueDepId: 0;
+    constructor(inputType: GraphQLInputObjectType | GraphQLList<any>, $value: Step);
+    deduplicate(peers: readonly BakedInputStep[]): BakedInputStep<any>[];
+    unbatchedExecute(extra: UnbatchedExecutionExtra, value: unknown): TData;
+}
+/**
+ * Takes a input type and matching value and performs runtime conversion of
+ * that type to the internal representation (if any).
+ */
+export declare function bakedInput<TArg = any>(inputType: GraphQLInputType, $value: Step): Step<any>;
+export declare function bakedInputRuntime(schema: GraphQLSchema, inputType: GraphQLInputType, value: unknown): unknown;
+//# sourceMappingURL=bakedInput.d.ts.map

package/dist/steps/bakedInput.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BakedInputStep = void 0;
+exports.bakedInput = bakedInput;
+exports.bakedInputRuntime = bakedInputRuntime;
+const graphql_1 = require("graphql");
+const step_js_1 = require("../step.js");
+const applyInput_js_1 = require("./applyInput.js");
+const index_js_1 = require("./index.js");
+class BakedInputStep extends step_js_1.UnbatchedStep {
+    static { this.$$export = {
+        moduleName: "grafast",
+        exportName: "BakedInputStep",
+    }; }
+    constructor(inputType, $value) {
+        super();
+        this.inputType = inputType;
+        this.isSyncAndSafe = true;
+        this.valueDepId = this.addUnaryDependency($value);
+        if (!this._isUnary) {
+            throw new Error(`bakedInput() must be unary`);
+        }
+        this._isUnaryLocked = true;
+    }
+    deduplicate(peers) {
+        return peers.filter((p) => p.inputType === this.inputType);
+    }
+    unbatchedExecute(extra, value) {
+        if (value == null)
+            return value;
+        return bakedInputRuntime(this.operationPlan.schema, this.inputType, value);
+    }
+}
+exports.BakedInputStep = BakedInputStep;
+/**
+ * Takes a input type and matching value and performs runtime conversion of
+ * that type to the internal representation (if any).
+ */
+function bakedInput(inputType, $value) {
+    const nullableInputType = (0, graphql_1.getNullableType)(inputType);
+    // Could have done this in `optimize()` but faster to do it here.
+    if ((0, graphql_1.isListType)(nullableInputType) ||
+        ((0, graphql_1.isInputObjectType)(nullableInputType) &&
+            typeof nullableInputType.extensions?.grafast?.baked === "function")) {
+        // Ooo, we're fancy! Do the thing!
+        return (0, index_js_1.operationPlan)().withRootLayerPlan(() => new BakedInputStep(nullableInputType, $value));
+    }
+    else {
+        // Nothing special, we just return the input.
+        return $value;
+    }
+}
+function bakedInputRuntime(schema, inputType, value) {
+    if (value == null)
+        return value;
+    const nullableInputType = (0, graphql_1.getNullableType)(inputType);
+    if ((0, graphql_1.isListType)(nullableInputType)) {
+        if (Array.isArray(value)) {
+            return value.map((v) => bakedInputRuntime(schema, nullableInputType.ofType, v));
+        }
+        else {
+            throw new Error(`Failed to process input for type ${inputType} - expected array`);
+        }
+    }
+    // Could have done this in `optimize()` but faster to do it here.
+    const baked = (0, graphql_1.isInputObjectType)(nullableInputType)
+        ? nullableInputType.extensions?.grafast?.baked
+        : null;
+    if (typeof baked !== "function") {
+        // Nothing special, we just return the input.
+        return value;
+    }
+    else {
+        // Ooo, we're fancy! Do the thing!
+        let applied = false;
+        const bakedObj = baked(value, {
+            type: nullableInputType,
+            schema,
+            applyChildren(parent) {
+                applied = true;
+                (0, applyInput_js_1.inputArgsApply)(schema, nullableInputType, parent, value, undefined);
+            },
+        });
+        if (!applied) {
+            (0, applyInput_js_1.inputArgsApply)(schema, nullableInputType, bakedObj, value, undefined);
+        }
+        return bakedObj;
+    }
+}
+//# sourceMappingURL=bakedInput.js.map

package/dist/steps/condition.d.ts

@@ -0,0 +1,31 @@
+import type { UnbatchedExecutionExtra } from "../interfaces.js";
+import type { Step } from "../step.js";
+import { UnbatchedStep } from "../step.js";
+declare const unaryOperators: readonly ["null", "not null", "exists", "not exists"];
+type UnaryOperator = (typeof unaryOperators)[number];
+declare const binaryOperators: readonly ["===", "!=="];
+type BinaryOperator = (typeof binaryOperators)[number];
+type Operator = UnaryOperator | BinaryOperator;
+export declare class ConditionStep extends UnbatchedStep<boolean> {
+    private op;
+    static $$export: {
+        moduleName: string;
+        exportName: string;
+    };
+    isSyncAndSafe: boolean;
+    allowMultipleOptimizations: boolean;
+    constructor(op: Operator, step1: Step, step2?: Step);
+    toStringMeta(): string | null;
+    finalize(): void;
+    private makeUnbatchedExecute;
+    unbatchedExecute(_extra: UnbatchedExecutionExtra, _value1: any, _value2: any): boolean;
+}
+type $Boolean = Step<boolean>;
+declare function condition(op: "null", step: Step): $Boolean;
+declare function condition(op: "not null", step: Step): $Boolean;
+declare function condition(op: "exists", step: Step): $Boolean;
+declare function condition(op: "not exists", step: Step): $Boolean;
+declare function condition(op: "===", step1: Step, step2: Step): $Boolean;
+declare function condition(op: "!==", step1: Step, step2: Step): $Boolean;
+export { condition };
+//# sourceMappingURL=condition.d.ts.map

package/dist/steps/condition.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConditionStep = void 0;
+exports.condition = condition;
+const step_js_1 = require("../step.js");
+const unaryOperators = ["null", "not null", "exists", "not exists"];
+const binaryOperators = ["===", "!=="];
+class ConditionStep extends step_js_1.UnbatchedStep {
+    static { this.$$export = {
+        moduleName: "grafast",
+        exportName: "ConditionStep",
+    }; }
+    constructor(op, step1, step2) {
+        super();
+        this.op = op;
+        this.isSyncAndSafe = true;
+        this.allowMultipleOptimizations = true;
+        if (!step2) {
+            // unary
+            if (!unaryOperators.includes(op)) {
+                throw new Error(`Unary operator '${op}' is not known; supported operators: ${unaryOperators.join(", ")}`);
+            }
+            this.addDependency(step1);
+        }
+        else {
+            // binary
+            if (!binaryOperators.includes(op)) {
+                throw new Error(`Unary operator '${op}' is not known; supported operators: ${binaryOperators.join(", ")}`);
+            }
+            this.addDependency(step1);
+            this.addDependency(step2);
+        }
+    }
+    toStringMeta() {
+        if (unaryOperators.includes(this.op)) {
+            return `${this.op}`;
+        }
+        else {
+            const $dep1 = this.getDepOptions(0).step;
+            const $dep2 = this.getDepOptions(1).step;
+            return `${$dep1.id} ${this.op} ${$dep2.id}`;
+        }
+    }
+    finalize() {
+        this.unbatchedExecute = this.makeUnbatchedExecute();
+        super.finalize();
+    }
+    makeUnbatchedExecute() {
+        switch (this.op) {
+            case "null":
+                return isNull;
+            case "not null":
+                return isNotNull;
+            case "exists":
+                return isNotNullish;
+            case "not exists":
+                return isNullish;
+            case "===":
+                return isEqual;
+            case "!==":
+                return isNotEqual;
+            default: {
+                const never = this.op;
+                throw new Error(`Operator ${never} is not supported`);
+            }
+        }
+    }
+    unbatchedExecute(_extra, _value1, _value2) {
+        throw new Error(`${this} was not finalized?`);
+    }
+}
+exports.ConditionStep = ConditionStep;
+function isNull(_extra, value1) {
+    return value1 === null;
+}
+function isNotNull(_extra, value1) {
+    return value1 !== null;
+}
+function isNullish(_extra, value1) {
+    return value1 == null;
+}
+function isNotNullish(_extra, value1) {
+    return value1 != null;
+}
+function isEqual(_extra, value1, value2) {
+    return value1 === value2;
+}
+function isNotEqual(_extra, value1, value2) {
+    return value1 !== value2;
+}
+function condition(op, step1, step2) {
+    return new ConditionStep(op, step1, step2);
+}
+//# sourceMappingURL=condition.js.map