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

package/dist/input.js

@@ -1,12 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.inputStep = exports.graphqlGetTypeForNode = exports.assertInputStep = void 0;
+exports.assertInputStep = assertInputStep;
+exports.graphqlGetTypeForNode = graphqlGetTypeForNode;
+exports.inputStep = inputStep;
 const tslib_1 = require("tslib");
 const graphql = tslib_1.__importStar(require("graphql"));
 const inspect_js_1 = require("./inspect.js");
+const __inputDefault_js_1 = require("./steps/__inputDefault.js");
 const __inputDynamicScalar_js_1 = require("./steps/__inputDynamicScalar.js");
 const __inputObject_js_1 = require("./steps/__inputObject.js");
 const index_js_1 = require("./steps/index.js");
+const utils_js_1 = require("./utils.js");
 const { assertScalarType, GraphQLError, GraphQLList, GraphQLNonNull, isInputType, isLeafType, isInputObjectType, Kind, } = graphql;
 function assertInputStep(itemPlan) {
     if (itemPlan instanceof index_js_1.__TrackedValueStep)
@@ -19,7 +23,6 @@ function assertInputStep(itemPlan) {
         return;
     throw new Error(`Expected an InputStep, but found ${itemPlan}`);
 }
-exports.assertInputStep = assertInputStep;
 function graphqlGetTypeForNode(operationPlan, node) {
     switch (node.kind) {
         case Kind.NAMED_TYPE: {
@@ -41,7 +44,6 @@ function graphqlGetTypeForNode(operationPlan, node) {
         }
     }
 }
-exports.graphqlGetTypeForNode = graphqlGetTypeForNode;
 /**
  * Returns a plan for the given `rawInputValue` AST node which could be a
  * variable or a literal, and could be nested so that a variable (or more than
@@ -49,14 +51,21 @@ exports.graphqlGetTypeForNode = graphqlGetTypeForNode;
  *
  * @internal
  */
-function inputStep(operationPlan, inputType, rawInputValue, defaultValue = undefined) {
-    // This prevents recursion
-    if (rawInputValue === undefined && defaultValue === undefined) {
-        return (0, index_js_1.constant)(undefined);
+function inputStep(operationPlan, inputType, inputValue, defaultValue = undefined) {
+    const { valueNodeToStaticValueCache } = operationPlan;
+    if (inputValue === undefined) {
+        // Definitely can't be or contain a variable!
+        if (defaultValue === undefined) {
+            return (0, index_js_1.constant)(undefined);
+        }
+        else {
+            return valueNodeToCachedStaticValueConstantStep(valueNodeToStaticValueCache, defaultValue, inputType);
+        }
     }
     const isObj = isInputObjectType(inputType);
-    let inputValue = rawInputValue;
-    if (inputValue?.kind === "Variable") {
+    if (inputValue.kind === "Variable") {
+        // Note: this is the only other place where `defaultValue` might be used
+        // we know `inputValue` is not a variable.
         const variableName = inputValue.name.value;
         const variableDefinition = operationPlan.operation.variableDefinitions?.find((def) => def.variable.name.value === variableName);
         if (!variableDefinition) {
@@ -68,17 +77,27 @@ function inputStep(operationPlan, inputType, rawInputValue, defaultValue = undef
         if (!isInputType(variableType)) {
             throw new Error(`Expected varible type to be an input type`);
         }
-        return inputVariablePlan(operationPlan, variableName, variableType, inputType, defaultValue);
+        const variableWillDefinitelyBeSet = variableType instanceof GraphQLNonNull ||
+            variableDefinition.defaultValue != null;
+        return inputVariablePlan(operationPlan, variableName, variableType, inputType, defaultValue, variableWillDefinitelyBeSet);
     }
-    // Note: past here we know whether `defaultValue` will be used or not because
-    // we know `inputValue` is not a variable.
-    inputValue = inputValue ?? defaultValue;
-    if (inputType instanceof GraphQLNonNull) {
+    else if (inputType instanceof GraphQLNonNull) {
         const innerType = inputType.ofType;
+        if (inputValue.kind === Kind.NULL) {
+            throw new Error(`Null found in non-null position; this should have been prevented by validation.`);
+        }
         const valuePlan = inputStep(operationPlan, innerType, inputValue, undefined);
         return inputNonNullPlan(operationPlan, valuePlan);
     }
+    else if (inputValue.kind === Kind.NULL) {
+        return (0, index_js_1.constant)(null);
+    }
     else if (inputType instanceof GraphQLList) {
+        const variableNames = new Set();
+        (0, utils_js_1.findVariableNamesUsedInValueNode)(inputValue, variableNames);
+        if (variableNames.size === 0) {
+            return valueNodeToCachedStaticValueConstantStep(valueNodeToStaticValueCache, inputValue, inputType);
+        }
         return new index_js_1.__InputListStep(inputType, inputValue);
     }
     else if (isLeafType(inputType)) {
@@ -100,7 +119,6 @@ function inputStep(operationPlan, inputType, rawInputValue, defaultValue = undef
         throw new Error(`Unsupported type in inputPlan: '${(0, inspect_js_1.inspect)(never)}'`);
     }
 }
-exports.inputStep = inputStep;
 function doTypesMatch(variableType, expectedType) {
     if (variableType instanceof GraphQLNonNull &&
         expectedType instanceof GraphQLNonNull) {
@@ -118,36 +136,57 @@ function doTypesMatch(variableType, expectedType) {
         return variableType === expectedType;
     }
 }
-function inputVariablePlan(operationPlan, variableName, variableType, inputType, defaultValue = undefined) {
+/**
+ * Returns a step representing a variable's value.
+ *
+ * @param operationPlan -
+ * @param variableName -
+ * @param variableType -
+ * @param inputType -
+ * @param defaultValue -
+ * @param variableWillDefinitelyBeSet - If `true` the variable is either
+ * non-null _or_ it has a default value (including null). In this case, the
+ * variable will never be `undefined` and thus an input position's defaultValue
+ * will never be invoked where it is used.
+ */
+function inputVariablePlan(operationPlan, variableName, variableType, inputType, defaultValue, variableWillDefinitelyBeSet) {
     if (variableType instanceof GraphQLNonNull &&
         !(inputType instanceof GraphQLNonNull)) {
         const unwrappedVariableType = variableType.ofType;
-        return inputVariablePlan(operationPlan, variableName, unwrappedVariableType, inputType, defaultValue);
+        return inputVariablePlan(operationPlan, variableName, unwrappedVariableType, inputType, defaultValue, variableWillDefinitelyBeSet);
     }
     const typesMatch = doTypesMatch(variableType, inputType);
     if (!typesMatch) {
         // REF: https://spec.graphql.org/draft/#IsVariableUsageAllowed()
         if (inputType instanceof GraphQLNonNull &&
             !(variableType instanceof GraphQLNonNull)) {
-            const variablePlan = inputVariablePlan(operationPlan, variableName, variableType, inputType.ofType, defaultValue);
-            if (variablePlan.evalIs(null) || variablePlan.evalIs(undefined)) {
+            const variablePlan = inputVariablePlan(operationPlan, variableName, variableType, inputType.ofType, defaultValue, variableWillDefinitelyBeSet);
+            // TODO: find a way to do this without doing eval. For example: track list of variables that may not be nullish.
+            if (variablePlan.evalIs(null) ||
+                (!variableWillDefinitelyBeSet && variablePlan.evalIs(undefined))) {
                 throw new GraphQLError(`Expected non-null value of type ${inputType.ofType.toString()}`);
             }
             return variablePlan;
         }
         throw new Error("Expected variable and input types to match");
     }
-    const variableValuePlan = operationPlan.trackedVariableValuesStep.get(variableName);
-    if (defaultValue === undefined || !variableValuePlan.evalIs(undefined)) {
-        // There's no default value, or we know for sure that our variable will be
-        // set (even if null) and thus the default will not be used; use the variable.
-        return variableValuePlan;
+    const $variableValue = operationPlan.trackedVariableValuesStep.get(variableName);
+    if (defaultValue === undefined) {
+        // There's no default value and thus the default will not be used; use the variable.
+        return $variableValue;
+    }
+    else if (variableWillDefinitelyBeSet) {
+        // The variable will DEFINITELY be set (even if it is set to null, possibly
+        // by a default), so the input position's default value will never apply.
+        return $variableValue;
     }
     else {
-        // `defaultValue` is NOT undefined, and we know variableValue is
-        // `undefined` (and always will be); we're going to loop back and pretend
-        // that no value was passed in the first place (instead of the variable):
-        return inputStep(operationPlan, inputType, undefined, defaultValue);
+        // Here:
+        // - the variable is nullable, optional, and has no default value
+        // - the input position has a default value
+        // We thus need a step that results in `variableValue === undefined ? defaultValue : variableValue`
+        const runtimeDefaultValue = (0, utils_js_1.valueNodeToStaticValue)(defaultValue, inputType);
+        return new __inputDefault_js_1.__InputDefaultStep($variableValue, runtimeDefaultValue);
     }
 }
 /**
@@ -156,4 +195,12 @@ function inputVariablePlan(operationPlan, variableName, variableType, inputType,
 function inputNonNullPlan(_operationPlan, innerPlan) {
     return innerPlan;
 }
+function valueNodeToCachedStaticValueConstantStep(cache, valueNode, inputType) {
+    let step = cache.get(valueNode);
+    if (!step) {
+        step = (0, index_js_1.constant)((0, utils_js_1.valueNodeToStaticValue)(valueNode, inputType), false);
+        cache.set(valueNode, step);
+    }
+    return step;
+}
 //# sourceMappingURL=input.js.map

package/dist/inspect.d.ts

@@ -1,4 +1,10 @@
-export declare let inspect: (obj: any, options?: {
-    colors: boolean;
-}) => string;
+export declare let inspect: {
+    (obj: any, options?: {
+        colors?: boolean;
+        depth?: number;
+        compact?: boolean | number;
+        breakLength?: number;
+    }): string;
+    custom: symbol;
+};
 //# sourceMappingURL=inspect.d.ts.map

package/dist/inspect.js

@@ -8,13 +8,13 @@ try {
     }
 }
 catch {
-    exports.inspect = (obj) => {
+    exports.inspect = Object.assign((obj) => {
         return Array.isArray(obj) ||
             !obj ||
             Object.getPrototypeOf(obj) === null ||
             Object.getPrototypeOf(obj) === Object.prototype
-            ? JSON.stringify(obj)
+            ? String(JSON.stringify(obj))
             : String(obj);
-    };
+    }, { custom: Symbol.for("nodejs.util.inspect.custom") });
 }
 //# sourceMappingURL=inspect.js.map