@pome-sh/cli 0.3.0 → 0.4.0

package/node_modules/graphql/utilities/typedQueryDocumentNode.js

@@ -0,0 +1,5 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});

package/node_modules/graphql/utilities/typedQueryDocumentNode.mjs

@@ -0,0 +1 @@
+export {};

package/node_modules/graphql/utilities/valueFromAST.d.ts

@@ -0,0 +1,67 @@
+/** @category Values */
+import type { Maybe } from '../jsutils/Maybe';
+import type { ObjMap } from '../jsutils/ObjMap';
+import type { ValueNode } from '../language/ast';
+import type { GraphQLInputType } from '../type/definition';
+/**
+ * Produces a JavaScript value given a GraphQL Value AST.
+ *
+ * A GraphQL type must be provided, which will be used to interpret different
+ * GraphQL Value literals.
+ *
+ * Returns `undefined` when the value could not be validly coerced according to
+ * the provided type.
+ *
+ * | GraphQL Value        | JSON Value    |
+ * | -------------------- | ------------- |
+ * | Input Object         | Object        |
+ * | List                 | Array         |
+ * | Boolean              | Boolean       |
+ * | String               | String        |
+ * | Int / Float          | Number        |
+ * | Enum Value           | Unknown       |
+ * | NullValue            | null          |
+ * @param valueNode - GraphQL value AST node to convert.
+ * @param type - The GraphQL type to inspect.
+ * @param variables - Optional runtime variable values keyed by variable name.
+ * @returns The coerced JavaScript value, or undefined if the AST value cannot be coerced to the type.
+ * @example
+ * ```ts
+ * // Coerce literal values without variables.
+ * import { parseValue } from 'graphql/language';
+ * import {
+ *   GraphQLInputObjectType,
+ *   GraphQLInt,
+ *   GraphQLList,
+ *   GraphQLNonNull,
+ *   GraphQLString,
+ * } from 'graphql/type';
+ * import { valueFromAST } from 'graphql/utilities';
+ *
+ * const ReviewInput = new GraphQLInputObjectType({
+ *   name: 'ReviewInput',
+ *   fields: {
+ *     stars: { type: new GraphQLNonNull(GraphQLInt) },
+ *     tags: { type: new GraphQLList(GraphQLString) },
+ *   },
+ * });
+ *
+ * valueFromAST(parseValue('{ stars: 5, tags: ["featured"] }'), ReviewInput); // => { stars: 5, tags: ['featured'] }
+ * valueFromAST(parseValue('{ stars: "bad" }'), ReviewInput); // => undefined
+ * ```
+ * @example
+ * ```ts
+ * // This variant resolves variable references from runtime values.
+ * import { parseValue } from 'graphql/language';
+ * import { GraphQLInt } from 'graphql/type';
+ * import { valueFromAST } from 'graphql/utilities';
+ *
+ * valueFromAST(parseValue('$stars'), GraphQLInt, { stars: 5 }); // => 5
+ * valueFromAST(parseValue('$stars'), GraphQLInt, {}); // => undefined
+ * ```
+ */
+export declare function valueFromAST(
+  valueNode: Maybe<ValueNode>,
+  type: GraphQLInputType,
+  variables?: Maybe<ObjMap<unknown>>,
+): unknown;

package/node_modules/graphql/utilities/valueFromAST.js

@@ -0,0 +1,246 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.valueFromAST = valueFromAST;
+
+var _inspect = require('../jsutils/inspect.js');
+
+var _invariant = require('../jsutils/invariant.js');
+
+var _keyMap = require('../jsutils/keyMap.js');
+
+var _kinds = require('../language/kinds.js');
+
+var _definition = require('../type/definition.js');
+
+/** @category Values */
+
+/**
+ * Produces a JavaScript value given a GraphQL Value AST.
+ *
+ * A GraphQL type must be provided, which will be used to interpret different
+ * GraphQL Value literals.
+ *
+ * Returns `undefined` when the value could not be validly coerced according to
+ * the provided type.
+ *
+ * | GraphQL Value        | JSON Value    |
+ * | -------------------- | ------------- |
+ * | Input Object         | Object        |
+ * | List                 | Array         |
+ * | Boolean              | Boolean       |
+ * | String               | String        |
+ * | Int / Float          | Number        |
+ * | Enum Value           | Unknown       |
+ * | NullValue            | null          |
+ * @param valueNode - GraphQL value AST node to convert.
+ * @param type - The GraphQL type to inspect.
+ * @param variables - Optional runtime variable values keyed by variable name.
+ * @returns The coerced JavaScript value, or undefined if the AST value cannot be coerced to the type.
+ * @example
+ * ```ts
+ * // Coerce literal values without variables.
+ * import { parseValue } from 'graphql/language';
+ * import {
+ *   GraphQLInputObjectType,
+ *   GraphQLInt,
+ *   GraphQLList,
+ *   GraphQLNonNull,
+ *   GraphQLString,
+ * } from 'graphql/type';
+ * import { valueFromAST } from 'graphql/utilities';
+ *
+ * const ReviewInput = new GraphQLInputObjectType({
+ *   name: 'ReviewInput',
+ *   fields: {
+ *     stars: { type: new GraphQLNonNull(GraphQLInt) },
+ *     tags: { type: new GraphQLList(GraphQLString) },
+ *   },
+ * });
+ *
+ * valueFromAST(parseValue('{ stars: 5, tags: ["featured"] }'), ReviewInput); // => { stars: 5, tags: ['featured'] }
+ * valueFromAST(parseValue('{ stars: "bad" }'), ReviewInput); // => undefined
+ * ```
+ * @example
+ * ```ts
+ * // This variant resolves variable references from runtime values.
+ * import { parseValue } from 'graphql/language';
+ * import { GraphQLInt } from 'graphql/type';
+ * import { valueFromAST } from 'graphql/utilities';
+ *
+ * valueFromAST(parseValue('$stars'), GraphQLInt, { stars: 5 }); // => 5
+ * valueFromAST(parseValue('$stars'), GraphQLInt, {}); // => undefined
+ * ```
+ */
+function valueFromAST(valueNode, type, variables) {
+  if (!valueNode) {
+    // When there is no node, then there is also no value.
+    // Importantly, this is different from returning the value null.
+    return;
+  }
+
+  if (valueNode.kind === _kinds.Kind.VARIABLE) {
+    const variableName = valueNode.name.value;
+
+    if (
+      variables == null ||
+      variables[variableName] === undefined ||
+      !hasOwnProperty(variables, variableName)
+    ) {
+      // No valid return value.
+      return;
+    }
+
+    const variableValue = variables[variableName];
+
+    if (variableValue === null && (0, _definition.isNonNullType)(type)) {
+      return; // Invalid: intentionally return no value.
+    } // Note: This does no further checking that this variable is correct.
+    // This assumes that this query has been validated and the variable
+    // usage here is of the correct type.
+
+    return variableValue;
+  }
+
+  if ((0, _definition.isNonNullType)(type)) {
+    if (valueNode.kind === _kinds.Kind.NULL) {
+      return; // Invalid: intentionally return no value.
+    }
+
+    return valueFromAST(valueNode, type.ofType, variables);
+  }
+
+  if (valueNode.kind === _kinds.Kind.NULL) {
+    // This is explicitly returning the value null.
+    return null;
+  }
+
+  if ((0, _definition.isListType)(type)) {
+    const itemType = type.ofType;
+
+    if (valueNode.kind === _kinds.Kind.LIST) {
+      const coercedValues = [];
+
+      for (const itemNode of valueNode.values) {
+        if (isMissingVariable(itemNode, variables)) {
+          // If an array contains a missing variable, it is either coerced to
+          // null or if the item type is non-null, it considered invalid.
+          if ((0, _definition.isNonNullType)(itemType)) {
+            return; // Invalid: intentionally return no value.
+          }
+
+          coercedValues.push(null);
+        } else {
+          const itemValue = valueFromAST(itemNode, itemType, variables);
+
+          if (itemValue === undefined) {
+            return; // Invalid: intentionally return no value.
+          }
+
+          coercedValues.push(itemValue);
+        }
+      }
+
+      return coercedValues;
+    }
+
+    const coercedValue = valueFromAST(valueNode, itemType, variables);
+
+    if (coercedValue === undefined) {
+      return; // Invalid: intentionally return no value.
+    }
+
+    return [coercedValue];
+  }
+
+  if ((0, _definition.isInputObjectType)(type)) {
+    if (valueNode.kind !== _kinds.Kind.OBJECT) {
+      return; // Invalid: intentionally return no value.
+    }
+
+    const coercedObj = Object.create(null);
+    const fieldNodes = (0, _keyMap.keyMap)(
+      valueNode.fields,
+      (field) => field.name.value,
+    );
+
+    for (const field of Object.values(type.getFields())) {
+      const fieldNode = fieldNodes[field.name];
+
+      if (!fieldNode || isMissingVariable(fieldNode.value, variables)) {
+        if (field.defaultValue !== undefined) {
+          coercedObj[field.name] = field.defaultValue;
+        } else if ((0, _definition.isNonNullType)(field.type)) {
+          return; // Invalid: intentionally return no value.
+        }
+
+        continue;
+      }
+
+      const fieldValue = valueFromAST(fieldNode.value, field.type, variables);
+
+      if (fieldValue === undefined) {
+        return; // Invalid: intentionally return no value.
+      }
+
+      coercedObj[field.name] = fieldValue;
+    }
+
+    if (type.isOneOf) {
+      const keys = Object.keys(coercedObj);
+
+      if (keys.length !== 1) {
+        return; // Invalid: not exactly one key, intentionally return no value.
+      }
+
+      if (coercedObj[keys[0]] === null) {
+        return; // Invalid: value not non-null, intentionally return no value.
+      }
+    }
+
+    return coercedObj;
+  }
+
+  if ((0, _definition.isLeafType)(type)) {
+    // Scalars and Enums fulfill parsing a literal value via parseLiteral().
+    // Invalid values represent a failure to parse correctly, in which case
+    // no value is returned.
+    let result;
+
+    try {
+      result = type.parseLiteral(valueNode, variables);
+    } catch (_error) {
+      return; // Invalid: intentionally return no value.
+    }
+
+    if (result === undefined) {
+      return; // Invalid: intentionally return no value.
+    }
+
+    return result;
+  }
+  /* c8 ignore next 3 */
+  // Not reachable, all possible input types have been considered.
+
+  false ||
+    (0, _invariant.invariant)(
+      false,
+      'Unexpected input type: ' + (0, _inspect.inspect)(type),
+    );
+} // Returns true if the provided valueNode is a variable which is not defined
+// in the set of variables.
+
+function isMissingVariable(valueNode, variables) {
+  return (
+    valueNode.kind === _kinds.Kind.VARIABLE &&
+    (variables == null ||
+      variables[valueNode.name.value] === undefined ||
+      !hasOwnProperty(variables, valueNode.name.value))
+  );
+}
+
+function hasOwnProperty(obj, prop) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}

package/node_modules/graphql/utilities/valueFromAST.mjs

@@ -0,0 +1,232 @@
+/** @category Values */
+import { inspect } from '../jsutils/inspect.mjs';
+import { invariant } from '../jsutils/invariant.mjs';
+import { keyMap } from '../jsutils/keyMap.mjs';
+import { Kind } from '../language/kinds.mjs';
+import {
+  isInputObjectType,
+  isLeafType,
+  isListType,
+  isNonNullType,
+} from '../type/definition.mjs';
+/**
+ * Produces a JavaScript value given a GraphQL Value AST.
+ *
+ * A GraphQL type must be provided, which will be used to interpret different
+ * GraphQL Value literals.
+ *
+ * Returns `undefined` when the value could not be validly coerced according to
+ * the provided type.
+ *
+ * | GraphQL Value        | JSON Value    |
+ * | -------------------- | ------------- |
+ * | Input Object         | Object        |
+ * | List                 | Array         |
+ * | Boolean              | Boolean       |
+ * | String               | String        |
+ * | Int / Float          | Number        |
+ * | Enum Value           | Unknown       |
+ * | NullValue            | null          |
+ * @param valueNode - GraphQL value AST node to convert.
+ * @param type - The GraphQL type to inspect.
+ * @param variables - Optional runtime variable values keyed by variable name.
+ * @returns The coerced JavaScript value, or undefined if the AST value cannot be coerced to the type.
+ * @example
+ * ```ts
+ * // Coerce literal values without variables.
+ * import { parseValue } from 'graphql/language';
+ * import {
+ *   GraphQLInputObjectType,
+ *   GraphQLInt,
+ *   GraphQLList,
+ *   GraphQLNonNull,
+ *   GraphQLString,
+ * } from 'graphql/type';
+ * import { valueFromAST } from 'graphql/utilities';
+ *
+ * const ReviewInput = new GraphQLInputObjectType({
+ *   name: 'ReviewInput',
+ *   fields: {
+ *     stars: { type: new GraphQLNonNull(GraphQLInt) },
+ *     tags: { type: new GraphQLList(GraphQLString) },
+ *   },
+ * });
+ *
+ * valueFromAST(parseValue('{ stars: 5, tags: ["featured"] }'), ReviewInput); // => { stars: 5, tags: ['featured'] }
+ * valueFromAST(parseValue('{ stars: "bad" }'), ReviewInput); // => undefined
+ * ```
+ * @example
+ * ```ts
+ * // This variant resolves variable references from runtime values.
+ * import { parseValue } from 'graphql/language';
+ * import { GraphQLInt } from 'graphql/type';
+ * import { valueFromAST } from 'graphql/utilities';
+ *
+ * valueFromAST(parseValue('$stars'), GraphQLInt, { stars: 5 }); // => 5
+ * valueFromAST(parseValue('$stars'), GraphQLInt, {}); // => undefined
+ * ```
+ */
+
+export function valueFromAST(valueNode, type, variables) {
+  if (!valueNode) {
+    // When there is no node, then there is also no value.
+    // Importantly, this is different from returning the value null.
+    return;
+  }
+
+  if (valueNode.kind === Kind.VARIABLE) {
+    const variableName = valueNode.name.value;
+
+    if (
+      variables == null ||
+      variables[variableName] === undefined ||
+      !hasOwnProperty(variables, variableName)
+    ) {
+      // No valid return value.
+      return;
+    }
+
+    const variableValue = variables[variableName];
+
+    if (variableValue === null && isNonNullType(type)) {
+      return; // Invalid: intentionally return no value.
+    } // Note: This does no further checking that this variable is correct.
+    // This assumes that this query has been validated and the variable
+    // usage here is of the correct type.
+
+    return variableValue;
+  }
+
+  if (isNonNullType(type)) {
+    if (valueNode.kind === Kind.NULL) {
+      return; // Invalid: intentionally return no value.
+    }
+
+    return valueFromAST(valueNode, type.ofType, variables);
+  }
+
+  if (valueNode.kind === Kind.NULL) {
+    // This is explicitly returning the value null.
+    return null;
+  }
+
+  if (isListType(type)) {
+    const itemType = type.ofType;
+
+    if (valueNode.kind === Kind.LIST) {
+      const coercedValues = [];
+
+      for (const itemNode of valueNode.values) {
+        if (isMissingVariable(itemNode, variables)) {
+          // If an array contains a missing variable, it is either coerced to
+          // null or if the item type is non-null, it considered invalid.
+          if (isNonNullType(itemType)) {
+            return; // Invalid: intentionally return no value.
+          }
+
+          coercedValues.push(null);
+        } else {
+          const itemValue = valueFromAST(itemNode, itemType, variables);
+
+          if (itemValue === undefined) {
+            return; // Invalid: intentionally return no value.
+          }
+
+          coercedValues.push(itemValue);
+        }
+      }
+
+      return coercedValues;
+    }
+
+    const coercedValue = valueFromAST(valueNode, itemType, variables);
+
+    if (coercedValue === undefined) {
+      return; // Invalid: intentionally return no value.
+    }
+
+    return [coercedValue];
+  }
+
+  if (isInputObjectType(type)) {
+    if (valueNode.kind !== Kind.OBJECT) {
+      return; // Invalid: intentionally return no value.
+    }
+
+    const coercedObj = Object.create(null);
+    const fieldNodes = keyMap(valueNode.fields, (field) => field.name.value);
+
+    for (const field of Object.values(type.getFields())) {
+      const fieldNode = fieldNodes[field.name];
+
+      if (!fieldNode || isMissingVariable(fieldNode.value, variables)) {
+        if (field.defaultValue !== undefined) {
+          coercedObj[field.name] = field.defaultValue;
+        } else if (isNonNullType(field.type)) {
+          return; // Invalid: intentionally return no value.
+        }
+
+        continue;
+      }
+
+      const fieldValue = valueFromAST(fieldNode.value, field.type, variables);
+
+      if (fieldValue === undefined) {
+        return; // Invalid: intentionally return no value.
+      }
+
+      coercedObj[field.name] = fieldValue;
+    }
+
+    if (type.isOneOf) {
+      const keys = Object.keys(coercedObj);
+
+      if (keys.length !== 1) {
+        return; // Invalid: not exactly one key, intentionally return no value.
+      }
+
+      if (coercedObj[keys[0]] === null) {
+        return; // Invalid: value not non-null, intentionally return no value.
+      }
+    }
+
+    return coercedObj;
+  }
+
+  if (isLeafType(type)) {
+    // Scalars and Enums fulfill parsing a literal value via parseLiteral().
+    // Invalid values represent a failure to parse correctly, in which case
+    // no value is returned.
+    let result;
+
+    try {
+      result = type.parseLiteral(valueNode, variables);
+    } catch (_error) {
+      return; // Invalid: intentionally return no value.
+    }
+
+    if (result === undefined) {
+      return; // Invalid: intentionally return no value.
+    }
+
+    return result;
+  }
+  /* c8 ignore next 3 */
+  // Not reachable, all possible input types have been considered.
+
+  false || invariant(false, 'Unexpected input type: ' + inspect(type));
+} // Returns true if the provided valueNode is a variable which is not defined
+// in the set of variables.
+
+function isMissingVariable(valueNode, variables) {
+  return (
+    valueNode.kind === Kind.VARIABLE &&
+    (variables == null ||
+      variables[valueNode.name.value] === undefined ||
+      !hasOwnProperty(variables, valueNode.name.value))
+  );
+}
+
+function hasOwnProperty(obj, prop) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}

package/node_modules/graphql/utilities/valueFromASTUntyped.d.ts

@@ -0,0 +1,36 @@
+/** @category Values */
+import type { Maybe } from '../jsutils/Maybe';
+import type { ObjMap } from '../jsutils/ObjMap';
+import type { ValueNode } from '../language/ast';
+/**
+ * Produces a JavaScript value given a GraphQL Value AST.
+ *
+ * Because no GraphQL type is provided, the returned JavaScript value reflects
+ * the provided GraphQL value AST.
+ *
+ * | GraphQL Value        | JavaScript Value |
+ * | -------------------- | ---------------- |
+ * | Input Object         | Object           |
+ * | List                 | Array            |
+ * | Boolean              | Boolean          |
+ * | String / Enum        | String           |
+ * | Int / Float          | Number           |
+ * | Null                 | null             |
+ * @param valueNode - GraphQL value AST node to convert.
+ * @param variables - Optional runtime variable values keyed by variable name.
+ * @returns JavaScript value represented by the GraphQL value AST.
+ * @example
+ * ```ts
+ * import { parseValue } from 'graphql/language';
+ * import { valueFromASTUntyped } from 'graphql/utilities';
+ *
+ * const value = valueFromASTUntyped(parseValue('[1, 2, 3]'));
+ *
+ * value; // => [1, 2, 3]
+ * valueFromASTUntyped(parseValue('$name'), { name: 'Ada' }); // => 'Ada'
+ * ```
+ */
+export declare function valueFromASTUntyped(
+  valueNode: ValueNode,
+  variables?: Maybe<ObjMap<unknown>>,
+): unknown;

package/node_modules/graphql/utilities/valueFromASTUntyped.js

@@ -0,0 +1,75 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.valueFromASTUntyped = valueFromASTUntyped;
+
+var _keyValMap = require('../jsutils/keyValMap.js');
+
+var _kinds = require('../language/kinds.js');
+
+/** @category Values */
+
+/**
+ * Produces a JavaScript value given a GraphQL Value AST.
+ *
+ * Because no GraphQL type is provided, the returned JavaScript value reflects
+ * the provided GraphQL value AST.
+ *
+ * | GraphQL Value        | JavaScript Value |
+ * | -------------------- | ---------------- |
+ * | Input Object         | Object           |
+ * | List                 | Array            |
+ * | Boolean              | Boolean          |
+ * | String / Enum        | String           |
+ * | Int / Float          | Number           |
+ * | Null                 | null             |
+ * @param valueNode - GraphQL value AST node to convert.
+ * @param variables - Optional runtime variable values keyed by variable name.
+ * @returns JavaScript value represented by the GraphQL value AST.
+ * @example
+ * ```ts
+ * import { parseValue } from 'graphql/language';
+ * import { valueFromASTUntyped } from 'graphql/utilities';
+ *
+ * const value = valueFromASTUntyped(parseValue('[1, 2, 3]'));
+ *
+ * value; // => [1, 2, 3]
+ * valueFromASTUntyped(parseValue('$name'), { name: 'Ada' }); // => 'Ada'
+ * ```
+ */
+function valueFromASTUntyped(valueNode, variables) {
+  switch (valueNode.kind) {
+    case _kinds.Kind.NULL:
+      return null;
+
+    case _kinds.Kind.INT:
+      return parseInt(valueNode.value, 10);
+
+    case _kinds.Kind.FLOAT:
+      return parseFloat(valueNode.value);
+
+    case _kinds.Kind.STRING:
+    case _kinds.Kind.ENUM:
+    case _kinds.Kind.BOOLEAN:
+      return valueNode.value;
+
+    case _kinds.Kind.LIST:
+      return valueNode.values.map((node) =>
+        valueFromASTUntyped(node, variables),
+      );
+
+    case _kinds.Kind.OBJECT:
+      return (0, _keyValMap.keyValMap)(
+        valueNode.fields,
+        (field) => field.name.value,
+        (field) => valueFromASTUntyped(field.value, variables),
+      );
+
+    case _kinds.Kind.VARIABLE:
+      return variables === null || variables === void 0
+        ? void 0
+        : variables[valueNode.name.value];
+  }
+}