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

package/dist/operationPlan-input.js

@@ -1,33 +1,70 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.withFieldArgsForArguments = void 0;
+exports.withFieldArgsForArguments = withFieldArgsForArguments;
+exports.getNullableInputTypeAtPath = getNullableInputTypeAtPath;
 const tslib_1 = require("tslib");
 const graphql = tslib_1.__importStar(require("graphql"));
-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 index_js_1 = require("./index.js");
+const inspect_js_1 = require("./inspect.js");
 const utils_js_1 = require("./utils.js");
-const { getNullableType, isEnumType, isInputObjectType, isListType, isScalarType, } = graphql;
+const { getNullableType, isInputObjectType, isListType } = graphql;
 function assertNotRuntime(operationPlan, description) {
     if (operationPlan.phase === "ready") {
         throw new Error(`${description} may only be called at planning time; however you have code that has attempted to call it during execution time. Please revisit your plan resolvers to locate the issue.`);
     }
 }
-function withFieldArgsForArguments(operationPlan, $parent, $all, field, applyAfterMode, callback) {
+function withFieldArgsForArguments(operationPlan, $all, field, $parent, applyAfterMode, coordinate, callback) {
     if (operationPlan.loc !== null)
         operationPlan.loc.push(`withFieldArgsForArguments(${field.name})`);
-    const schema = operationPlan.schema;
     const args = Object.create(null);
     for (const arg of field.args) {
         args[arg.name] = arg;
     }
-    const got = new Map();
     const applied = new Map();
     let explicitlyApplied = false;
     const fieldArgs = {
+        typeAt(path) {
+            if (typeof path === "string") {
+                return args[path].type;
+            }
+            else {
+                if (path.length === 0) {
+                    throw new Error(`typeAt can only be used with a non-empty path since arguments themselves don't belong to a type but a field.`);
+                }
+                const argName = path[0];
+                let type = args[argName]?.type;
+                if (!type) {
+                    throw new Error(`Argument ${argName} does not exist`);
+                }
+                for (let i = 1, l = path.length; i < l; i++) {
+                    const segment = path[i];
+                    type = graphql.isNonNullType(type) ? type.ofType : type;
+                    if (typeof segment === "number") {
+                        if (!isListType(type)) {
+                            throw new Error(`Invalid path ${path.slice(1)} within argument ${argName}; expected a list at path index ${i - 1}`);
+                        }
+                        type = type.ofType;
+                    }
+                    else {
+                        if (!isInputObjectType(type)) {
+                            throw new Error(`Invalid path ${path.slice(1)} within argument ${argName}; expected an object at path index ${i - 1}`);
+                        }
+                        const arg = type.getFields()[segment];
+                        if (!arg) {
+                            throw new Error(`Invalid path ${path.slice(1)} within argument ${argName}; ${type} does not have a field '${segment}'`);
+                        }
+                        type = arg.type;
+                    }
+                }
+                return type;
+            }
+        },
         getRaw(path) {
             assertNotRuntime(operationPlan, `fieldArgs.getRaw()`);
-            if (typeof path === "string") {
+            if (path === undefined) {
+                return (0, index_js_1.object)(Object.fromEntries(Object.keys(args).map((argName) => [argName, $all.get(argName)])));
+            }
+            else if (typeof path === "string") {
                 return $all.get(path);
             }
             else if (Array.isArray(path)) {
@@ -50,201 +87,47 @@ function withFieldArgsForArguments(operationPlan, $parent, $all, field, applyAft
                 return $entry;
             }
             else {
-                throw new Error(`Invalid path`);
+                throw new Error(`Invalid path passed to FieldArgs.getRaw(); please check your code. Path: ${(0, inspect_js_1.inspect)(path)}`);
             }
         },
-        get(inPath) {
-            assertNotRuntime(operationPlan, `fieldArgs.get()`);
-            const path = Array.isArray(inPath)
-                ? inPath
-                : inPath
-                    ? [inPath]
-                    : [];
-            const pathString = path.join(".");
-            const $existing = got.get(pathString);
-            if ($existing) {
-                return $existing;
-            }
-            if (path.length === 0) {
-                const values = Object.create(null);
-                for (const argName of Object.keys(args)) {
-                    values[argName] = fieldArgs.get([argName]);
-                }
-                return (0, object_js_1.object)(values);
-            }
-            else {
-                const [argName, ...rest] = path;
-                if (typeof argName !== "string") {
-                    throw new Error(`Invalid path; argument '${argName}' is an invalid argument name`);
-                }
-                let entity = args[argName];
-                if (!entity) {
-                    throw new Error(`Invalid path; argument '${argName}' does not exist`);
-                }
-                let entityType = entity.type;
-                let $val = $all.get(argName);
-                for (const pathSegment of rest) {
-                    const nullableType = getNullableType(entityType);
-                    if (typeof pathSegment === "string" &&
-                        isInputObjectType(nullableType)) {
-                        entity = nullableType.getFields()[pathSegment];
-                        entityType = entity.type;
-                        if ("get" in $val) {
-                            $val = $val.get(pathSegment);
-                        }
-                        else if ($val instanceof constant_js_1.ConstantStep && $val.isUndefined()) {
-                            $val = (0, constant_js_1.constant)(undefined);
-                        }
-                        else {
-                            throw new Error(`GrafastInternalError<b9e9a57a-bbdd-486c-bdcf-25cf99bf0243>: Processing input object type, but '${$val}' has no .get() method.`);
-                        }
-                    }
-                    else if (typeof pathSegment === "number" &&
-                        isListType(nullableType)) {
-                        entity = null;
-                        entityType = nullableType.ofType;
-                        if ("at" in $val) {
-                            $val = $val.at(pathSegment);
-                        }
-                        else {
-                            throw new Error(`GrafastInternalError<0abe76fa-c87a-4477-aebd-feffef848c2b>: Processing input object type, but '${$val}' has no .get() method.`);
-                        }
-                    }
-                    else {
-                        throw new Error(`Asked to navigate ('get' mode) to position '${pathSegment}' (${typeof pathSegment}) (in path '${path.join(".")}') for incompatible type '${nullableType}' (${nullableType.constructor.name})`);
-                    }
-                }
-                let result;
-                const childFieldArgs = getFieldArgsForPath(path, entityType, $val, "input");
-                if (rest.length === 0) {
-                    // Argument
-                    const arg = entity;
-                    const argInputPlan = arg.extensions.grafast?.inputPlan;
-                    const fnDescription = `???.${field.name}(${arg.name}:).inputPlan`;
-                    (0, utils_js_1.assertNotAsync)(argInputPlan, fnDescription);
-                    result = argInputPlan
-                        ? (0, utils_js_1.assertNotPromise)(argInputPlan($parent, childFieldArgs, {
-                            schema,
-                            entity: arg,
-                        }), argInputPlan, fnDescription)
-                        : childFieldArgs.get();
-                }
-                else {
-                    // Input field
-                    const inputField = entity;
-                    const inputFieldInputPlan = inputField?.extensions.grafast?.inputPlan;
-                    const fnDescription = `???.${inputField?.name}.inputPlan`;
-                    (0, utils_js_1.assertNotAsync)(inputFieldInputPlan, fnDescription);
-                    result = inputFieldInputPlan
-                        ? (0, utils_js_1.assertNotPromise)(inputFieldInputPlan(childFieldArgs, {
-                            schema,
-                            entity: inputField,
-                        }), inputFieldInputPlan, fnDescription)
-                        : childFieldArgs.get();
-                }
-                const nullableType = getNullableType(entityType);
-                if (isInputObjectType(nullableType)) {
-                    processAfter(fieldArgs, path, result, nullableType.getFields(), "autoApplyAfterParentInputPlan");
-                }
-                return result;
-            }
-        },
-        apply(targetStepOrCallback, inPath) {
+        apply($target, inPathOrGetTargetFromParent, maybeGetTargetFromParent) {
+            const inPath = typeof inPathOrGetTargetFromParent === "function"
+                ? undefined
+                : inPathOrGetTargetFromParent;
+            const getTargetFromParent = typeof inPathOrGetTargetFromParent === "function"
+                ? inPathOrGetTargetFromParent
+                : maybeGetTargetFromParent;
             assertNotRuntime(operationPlan, `fieldArgs.apply()`);
             const path = Array.isArray(inPath) ? inPath : inPath ? [inPath] : [];
             const pathString = path.join(".");
             const $existing = applied.get(pathString);
             if ($existing) {
-                throw new Error(`Attempted to apply 'applyPlan' at input path ${pathString} more than once - first time to ${$existing}, second time to ${targetStepOrCallback}. Multiple applications are not currently supported.`);
+                throw new Error(`Attempted to apply 'applyPlan' at input path ${pathString} more than once - first time to ${$existing}, second time to ${$target}. Multiple applications are not currently supported.`);
             }
             if (path.length === 0) {
                 explicitlyApplied = true;
                 // Auto-apply all the arguments
                 for (const argName of Object.keys(args)) {
-                    const $target = typeof targetStepOrCallback === "function"
-                        ? targetStepOrCallback()
-                        : targetStepOrCallback;
                     fieldArgs.apply($target, [argName]);
                 }
             }
             else {
                 const [argName, ...rest] = path;
-                let entity = args[argName];
-                if (!entity) {
+                if (typeof argName !== "string") {
+                    throw new Error(`Invalid path; argument '${argName}' is an invalid argument name`);
+                }
+                const arg = args[argName];
+                if (!arg) {
                     throw new Error(`Invalid path; argument '${argName}' does not exist`);
                 }
-                let entityType = entity.type;
-                let $val = $all.get(argName);
-                for (const pathSegment of rest) {
-                    const nullableType = getNullableType(entityType);
-                    if (isInputObjectType(nullableType)) {
-                        entity = nullableType.getFields()[pathSegment];
-                        entityType = entity.type;
-                        if ("get" in $val) {
-                            $val = $val.get(pathSegment);
-                        }
-                        else {
-                            throw new Error(`GrafastInternalError<91e1e80d-cf24-4828-a749-3f24156c7b9c>: Processing input object type, but '${$val}' has no .get() method.`);
-                        }
-                    }
-                    else if (typeof pathSegment === "number" &&
-                        isListType(nullableType)) {
-                        entity = null;
-                        entityType = nullableType.ofType;
-                        if ("at" in $val) {
-                            $val = $val.at(pathSegment);
-                        }
-                        else {
-                            throw new Error(`GrafastInternalError<a097a130-f68f-4a5c-bd0c-24fcd26127a9>: Processing list type, but '${$val}' has no .at() method.`);
-                        }
-                    }
-                    else {
-                        throw new Error(`Asked to navigate ('apply' mode) to position '${pathSegment}' (${typeof pathSegment}) (in path '${path.join(".")}') for incompatible type '${nullableType}' (${nullableType.constructor.name})`);
-                    }
+                const typeAtPath = getNullableInputTypeAtPath(arg.type, rest);
+                const $valueAtPath = fieldArgs.getRaw(inPath);
+                if ($valueAtPath instanceof index_js_1.ConstantStep &&
+                    $valueAtPath.data === undefined) {
+                    // Skip applying!
                 }
-                if (notUndefined($val)) {
-                    const childFieldArgs = getFieldArgsForPath(path, entityType, $val, "apply");
-                    operationPlan.withModifiers(() => {
-                        let result;
-                        const $target = typeof targetStepOrCallback === "function"
-                            ? targetStepOrCallback()
-                            : targetStepOrCallback;
-                        if (rest.length === 0) {
-                            // Argument
-                            const arg = entity;
-                            const argApplyPlan = arg.extensions.grafast?.applyPlan;
-                            const fnDescription = `???.${field.name}(${arg.name}:).applyPlan`;
-                            (0, utils_js_1.assertNotAsync)(argApplyPlan, fnDescription);
-                            result = argApplyPlan
-                                ? (0, utils_js_1.assertNotPromise)(argApplyPlan($parent, $target, childFieldArgs, {
-                                    schema,
-                                    entity: arg,
-                                }), argApplyPlan, fnDescription)
-                                : undefined;
-                        }
-                        else if (entity) {
-                            // input field
-                            const inputField = entity;
-                            const inputFieldApplyPlan = inputField.extensions.grafast?.applyPlan;
-                            const fnDescription = `???.${inputField.name}.applyPlan`;
-                            (0, utils_js_1.assertNotAsync)(inputFieldApplyPlan, fnDescription);
-                            result = inputFieldApplyPlan
-                                ? (0, utils_js_1.assertNotPromise)(inputFieldApplyPlan($target, childFieldArgs, {
-                                    schema,
-                                    entity: inputField,
-                                }), inputFieldApplyPlan, fnDescription)
-                                : undefined;
-                        }
-                        else {
-                            childFieldArgs.apply($target);
-                            // Shortcut 'processAfter'
-                            return;
-                        }
-                        const nullableType = getNullableType(entityType);
-                        if (isInputObjectType(nullableType)) {
-                            processAfter(fieldArgs, path, result, nullableType.getFields(), "autoApplyAfterParentApplyPlan");
-                        }
-                    });
+                else {
+                    $target.apply((0, index_js_1.applyInput)(typeAtPath, $valueAtPath, getTargetFromParent));
                 }
             }
         },
@@ -253,237 +136,86 @@ function withFieldArgsForArguments(operationPlan, $parent, $all, field, applyAft
         let val;
         Object.defineProperty(fieldArgs, `$${argName}`, {
             get() {
-                if (!val) {
-                    val = fieldArgs.getRaw(argName);
-                }
-                return val;
+                return (val ??= fieldArgs.getRaw(argName));
             },
         });
     }
-    function getFieldArgsForPath(path, entityType, $input, mode) {
-        const nullableEntityType = getNullableType(entityType);
-        const localFieldArgs = {
-            getRaw(subpath) {
-                assertNotRuntime(operationPlan, `fieldArgs.getRaw()`);
-                return fieldArgs.getRaw(concatPath(path, subpath));
-            },
-            get(subpath) {
-                assertNotRuntime(operationPlan, `fieldArgs.get()`);
-                if (!subpath || (Array.isArray(subpath) && subpath.length === 0)) {
-                    if (isListType(nullableEntityType)) {
-                        if (!("evalLength" in $input)) {
-                            throw new Error(`GrafastInternalError<6ef74af7-7be0-4117-870f-2ebabcf5161c>: Expected ${$input} to be a __InputListStep or __TrackedValueStep (i.e. to have 'evalLength')`);
-                        }
-                        const l = $input.evalLength();
-                        if (l == null) {
-                            return (0, constant_js_1.constant)(null);
-                        }
-                        const entries = [];
-                        for (let i = 0; i < l; i++) {
-                            const entry = fieldArgs.get([...path, i]);
-                            entries.push(entry);
-                        }
-                        return (0, list_js_1.list)(entries);
-                    }
-                    else if (isInputObjectType(nullableEntityType)) {
-                        const typeResolver = nullableEntityType.extensions.grafast?.inputPlan ||
-                            defaultInputObjectTypeInputPlanResolver;
-                        const fnDescription = `${nullableEntityType}.inputPlan`;
-                        (0, utils_js_1.assertNotAsync)(typeResolver, fnDescription);
-                        const resolvedResult = (0, utils_js_1.assertNotPromise)(typeResolver(getFieldArgsForPath(path, nullableEntityType, $input, "input"), {
-                            schema,
-                            type: nullableEntityType,
-                        }), typeResolver, fnDescription);
-                        if (mode === "apply") {
-                            // NOTE: if mode === 'input' then `.get()` won't need a
-                            // `processAfter` since that will already have been handled in
-                            // the parent fieldArgs.
-                            processAfter(fieldArgs, path, resolvedResult, nullableEntityType.getFields(), "autoApplyAfterParentInputPlan");
-                        }
-                        return resolvedResult;
-                    }
-                    else if (isScalarType(nullableEntityType)) {
-                        const scalarResolver = nullableEntityType.extensions.grafast?.inputPlan;
-                        const fnDescription = `${nullableEntityType}.inputPlan`;
-                        (0, utils_js_1.assertNotAsync)(scalarResolver, fnDescription);
-                        if (scalarResolver !== undefined) {
-                            return (0, utils_js_1.assertNotPromise)(scalarResolver($input, {
-                                schema,
-                                type: nullableEntityType,
-                            }), scalarResolver, fnDescription);
-                        }
-                        else {
-                            return $input;
-                        }
-                    }
-                    else if (isEnumType(nullableEntityType)) {
-                        /*
-                        const enumResolver = nullableEntityType.extensions.grafast?.inputPlan;
-                        if (enumResolver) {
-                          return enumResolver($input, { schema, type: nullableEntityType });
-                        } else {
-                          return $input;
-                        }
-                        */
-                        return $input;
-                    }
-                    else {
-                        throw new Error(`Call to fieldArgs.get() at input path '${path.join(".")}' must pass a non-empty subpath`);
-                    }
-                }
-                return fieldArgs.get(concatPath(path, subpath));
-            },
-            apply(targetStepOrCallback, subpath) {
-                assertNotRuntime(operationPlan, `fieldArgs.apply()`);
-                if (mode === "apply" &&
-                    (!subpath || (Array.isArray(subpath) && subpath.length === 0))) {
-                    if (isInputObjectType(nullableEntityType)) {
-                        if (!("evalKeys" in $input)) {
-                            throw new Error(`GrafastInternalError<d782160e-7a99-4a12-b690-435c1ab7b676>: Expected ${$input} to be a __InputObjectStep or __TrackedValueStep (i.e. to have 'evalKeys')`);
-                        }
-                        const keys = $input.evalKeys();
-                        if (keys == null) {
-                            return;
-                        }
-                        for (const fieldName of keys) {
-                            const $target = typeof targetStepOrCallback === "function"
-                                ? targetStepOrCallback()
-                                : targetStepOrCallback;
-                            fieldArgs.apply($target, [...path, fieldName]);
-                        }
-                    }
-                    else if (isListType(nullableEntityType)) {
-                        if (!("evalLength" in $input)) {
-                            throw new Error(`GrafastInternalError<6ef74af7-7be0-4117-870f-2ebabcf5161c>: Expected ${$input} to be a __InputListStep or __TrackedValueStep (i.e. to have 'evalLength')`);
-                        }
-                        const l = $input.evalLength();
-                        if (l == null) {
-                            return;
-                        }
-                        // const innerType = nullableEntityType.ofType;
-                        for (let i = 0; i < l; i++) {
-                            const $target = typeof targetStepOrCallback === "function"
-                                ? targetStepOrCallback()
-                                : targetStepOrCallback;
-                            fieldArgs.apply($target, [...path, i]);
-                        }
-                    }
-                    else if (isScalarType(nullableEntityType)) {
-                        // noop
-                    }
-                    else if (isEnumType(nullableEntityType)) {
-                        // PERF: only do this if this enum type has values that have side effects
-                        const value = $input.eval();
-                        const enumValue = nullableEntityType
-                            .getValues()
-                            .find((v) => v.value === value);
-                        if (enumValue) {
-                            const enumResolver = enumValue.extensions.grafast?.applyPlan;
-                            const fnDescription = `${nullableEntityType.name}.${enumValue.name}.applyPlan`;
-                            (0, utils_js_1.assertNotAsync)(enumResolver, fnDescription);
-                            if (enumResolver !== undefined) {
-                                const $target = typeof targetStepOrCallback === "function"
-                                    ? targetStepOrCallback()
-                                    : targetStepOrCallback;
-                                (0, utils_js_1.assertNotPromise)(enumResolver($target), enumResolver, fnDescription);
-                            }
-                        }
-                    }
-                    else {
-                        const never = nullableEntityType;
-                        throw new Error(`Unhandled input type ${never}`);
-                    }
-                }
-                else {
-                    const $target = typeof targetStepOrCallback === "function"
-                        ? targetStepOrCallback()
-                        : targetStepOrCallback;
-                    fieldArgs.apply($target, concatPath(path, subpath));
-                }
-            },
-        };
-        if (isInputObjectType(nullableEntityType)) {
-            const inputFields = nullableEntityType.getFields();
-            for (const fieldName of Object.keys(inputFields)) {
-                let val;
-                Object.defineProperty(localFieldArgs, `$${fieldName}`, {
-                    enumerable: true,
-                    get() {
-                        if (!val) {
-                            if ("get" in $input) {
-                                val = $input.get(fieldName);
-                            }
-                            else if ($input instanceof constant_js_1.ConstantStep &&
-                                $input.isUndefined()) {
-                                val = (0, constant_js_1.constant)(undefined);
-                            }
-                            else {
-                                throw new Error(`GrafastInternalError<9b70d5c0-c45f-4acd-8b94-eaa02f87ad41>: expected '${$input}' to have a .get() method`);
-                            }
-                        }
-                        return val;
-                    },
-                });
-            }
-        }
-        return localFieldArgs;
-    }
     const result = callback(fieldArgs);
     (0, utils_js_1.assertNotPromise)(result, callback, operationPlan.loc?.join(">") ?? "???");
-    if (!explicitlyApplied) {
-        processAfter(fieldArgs, [], result, args, applyAfterMode);
+    if (!explicitlyApplied && result != null) {
+        processAfter($parent, fieldArgs, result, args, applyAfterMode, coordinate);
     }
     if (operationPlan.loc !== null)
         operationPlan.loc.pop();
     return (result ?? null);
 }
-exports.withFieldArgsForArguments = withFieldArgsForArguments;
-function processAfter(rootFieldArgs, path, result, fields, applyAfterMode) {
-    if (result != null && !(result instanceof constant_js_1.ConstantStep && result.isNull())) {
-        if (applyAfterMode === "autoApplyAfterParentApplyPlan" && result != null) {
-            // `applyPlan` returned a step, so auto-apply every subfield to it
-            for (const name of Object.keys(fields)) {
-                rootFieldArgs.apply(result, [...path, name]);
+function processAfter($parent, rootFieldArgs, $result, args, applyAfterMode, coordinate) {
+    const schema = $parent.operationPlan.schema;
+    for (const [argName, arg] of Object.entries(args)) {
+        const autoApply = applyAfterMode === "plan"
+            ? arg.extensions.grafast?.applyPlan
+            : applyAfterMode === "subscribePlan"
+                ? arg.extensions.grafast?.applySubscribePlan
+                : null;
+        if (autoApply) {
+            // TODO: should this have dollars on it for accessing subkeys?
+            const input = {
+                typeAt(path) {
+                    return rootFieldArgs.typeAt(concatPath(argName, path));
+                },
+                getRaw(path) {
+                    return rootFieldArgs.getRaw(concatPath(argName, path));
+                },
+                apply($target, pathOrTargetGetter, maybeTargetGetter) {
+                    if (typeof pathOrTargetGetter === "function") {
+                        return rootFieldArgs.apply($target, [argName], pathOrTargetGetter);
+                    }
+                    else {
+                        return rootFieldArgs.apply($target, concatPath(argName, pathOrTargetGetter), maybeTargetGetter);
+                    }
+                },
+            };
+            const result = autoApply($parent, $result, input, {
+                schema,
+                arg,
+                argName,
+            });
+            if (result !== undefined) {
+                const fullCoordinate = `${coordinate}(${argName}:)`;
+                throw new Error(`Argument ${fullCoordinate}'s applyPlan returned a value. This may indicate a bug in that method, please see https://err.red/gaap#coord=${encodeURIComponent(fullCoordinate)}`);
+            }
+        }
+    }
+}
+function getNullableInputTypeAtPath(startType, path) {
+    let type = getNullableType(startType);
+    for (let i = 0, l = path.length; i < l; i++) {
+        const segment = path[i];
+        if (typeof segment === "number") {
+            // Expect list
+            if (!isListType(type)) {
+                throw new Error(`Invalid path passed to fieldArgs.get(); expected list type, but found ${type}`);
             }
+            type = getNullableType(type.ofType);
         }
         else {
-            for (const [name, spec] of Object.entries(fields)) {
-                const autoApply = applyAfterMode === "autoApplyAfterParentPlan"
-                    ? spec.extensions.grafast
-                        ?.autoApplyAfterParentPlan
-                    : applyAfterMode === "autoApplyAfterParentSubscribePlan"
-                        ? spec.extensions.grafast
-                            ?.autoApplyAfterParentSubscribePlan
-                        : applyAfterMode === "autoApplyAfterParentInputPlan"
-                            ? spec.extensions.grafast
-                                ?.autoApplyAfterParentInputPlan
-                            : applyAfterMode === "autoApplyAfterParentApplyPlan"
-                                ? spec.extensions.grafast
-                                    ?.autoApplyAfterParentApplyPlan
-                                : null;
-                if (autoApply) {
-                    rootFieldArgs.apply(result, [...path, name]);
-                }
+            // Must be a string
+            if (!isInputObjectType(type)) {
+                throw new Error(`Invalid path passed to fieldArgs.get(); expected object type, but found ${type}`);
             }
+            const field = type.getFields()[segment];
+            if (!field) {
+                throw new Error(`Invalid path passed to fieldArgs.get(); ${type} has no field named ${segment}`);
+            }
+            type = getNullableType(field.type);
         }
     }
+    return type;
 }
-function concatPath(path, subpath) {
-    const localPath = Array.isArray(subpath) ? subpath : subpath ? [subpath] : [];
-    return [...path, ...localPath];
-}
-function notUndefined($value) {
-    // OPTIMIZE: having a lot of 'is undefined' checks is expensive; instead we
-    // should optimize this so that it tracks the set of keys that are set and
-    // matches against those as a single operation.
-    return !("evalIs" in $value && $value.evalIs(undefined));
+function concatPath(argName, subpath) {
+    if (subpath == null)
+        return [argName];
+    const localPath = Array.isArray(subpath) ? subpath : [subpath];
+    return [argName, ...localPath];
 }
-const defaultInputObjectTypeInputPlanResolver = (input, info) => {
-    const fields = info.type.getFields();
-    const obj = Object.create(null);
-    for (const fieldName in fields) {
-        obj[fieldName] = input.get(fieldName);
-    }
-    return (0, object_js_1.object)(obj);
-};
 //# sourceMappingURL=operationPlan-input.js.map

package/dist/planJSONInterfaces.d.ts

@@ -16,6 +16,9 @@ export interface GrafastPlanStepJSONv1 {
     isSyncAndSafe: boolean | undefined;
     supportsUnbatched: boolean | undefined;
     hasSideEffects: boolean | undefined;
+    stream: {
+        initialCountStepId?: number;
+    } | undefined;
     extra?: Record<string, JSONValue | undefined>;
 }
 export interface GrafastPlanBucketPhaseJSONv1 {
@@ -37,8 +40,9 @@ export interface GrafastPlanBucketReasonListItemJSONv1 {
     parentStepId: string | number;
     /** If this listItem is to be streamed, the configuration for that streaming */
     stream?: {
-        initialCount: number;
-        label?: string;
+        initialCountStepId?: number;
+        ifStepId?: number;
+        labelStepId?: number;
     };
 }
 /** Non-branching, deferred */

package/dist/polymorphic.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveType = exports.polymorphicWrap = exports.assertPolymorphicData = exports.isPolymorphicData = void 0;
+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) {
@@ -12,13 +15,11 @@ function isPolymorphicData(data) {
     }
     return true;
 }
-exports.isPolymorphicData = isPolymorphicData;
 function assertPolymorphicData(data) {
     if (!isPolymorphicData(data)) {
         throw new Error(`Expected a polymorphic object, received ${(0, inspect_js_1.inspect)(data)}`);
     }
 }
-exports.assertPolymorphicData = assertPolymorphicData;
 // const EMPTY_OBJECT = Object.freeze(Object.create(null));
 /**
  * Returns an object with the given concrete type (and, optionally, associated
@@ -50,7 +51,6 @@ data = Object.create(null)) {
     });
     */
 }
-exports.polymorphicWrap = polymorphicWrap;
 /**
  * All polymorphic objects in Grafast have a $$concreteType property which
  * contains the GraphQL object's type name; we simply return that.
@@ -59,7 +59,6 @@ function resolveType(o) {
     assertPolymorphicData(o);
     return o[interfaces_js_1.$$concreteType];
 }
-exports.resolveType = resolveType;
 /* 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