@pome-sh/cli 0.3.0 → 0.5.0

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

@@ -0,0 +1,26 @@
+/** @category Operations */
+import type { Maybe } from '../jsutils/Maybe';
+import type { DocumentNode, OperationDefinitionNode } from '../language/ast';
+/**
+ * Returns an operation AST given a document AST and optionally an operation
+ * name. If a name is not provided, an operation is only returned if only one is
+ * provided in the document.
+ * @param documentAST - The parsed GraphQL document AST.
+ * @param operationName - The optional operation name to select.
+ * @returns The resolved operation ast.
+ * @example
+ * ```ts
+ * import { parse } from 'graphql/language';
+ * import { getOperationAST } from 'graphql/utilities';
+ *
+ * const document = parse('query GetName { name }');
+ * const operation = getOperationAST(document, 'GetName');
+ *
+ * operation.name.value; // => 'GetName'
+ * getOperationAST(document, 'Missing'); // => undefined
+ * ```
+ */
+export declare function getOperationAST(
+  documentAST: DocumentNode,
+  operationName?: Maybe<string>,
+): Maybe<OperationDefinitionNode>;

package/node_modules/graphql/utilities/getOperationAST.js

@@ -0,0 +1,59 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.getOperationAST = getOperationAST;
+
+var _kinds = require('../language/kinds.js');
+
+/** @category Operations */
+
+/**
+ * Returns an operation AST given a document AST and optionally an operation
+ * name. If a name is not provided, an operation is only returned if only one is
+ * provided in the document.
+ * @param documentAST - The parsed GraphQL document AST.
+ * @param operationName - The optional operation name to select.
+ * @returns The resolved operation ast.
+ * @example
+ * ```ts
+ * import { parse } from 'graphql/language';
+ * import { getOperationAST } from 'graphql/utilities';
+ *
+ * const document = parse('query GetName { name }');
+ * const operation = getOperationAST(document, 'GetName');
+ *
+ * operation.name.value; // => 'GetName'
+ * getOperationAST(document, 'Missing'); // => undefined
+ * ```
+ */
+function getOperationAST(documentAST, operationName) {
+  let operation = null;
+
+  for (const definition of documentAST.definitions) {
+    if (definition.kind === _kinds.Kind.OPERATION_DEFINITION) {
+      var _definition$name;
+
+      if (operationName == null) {
+        // If no operation name was provided, only return an Operation if there
+        // is one defined in the document. Upon encountering the second, return
+        // null.
+        if (operation) {
+          return null;
+        }
+
+        operation = definition;
+      } else if (
+        ((_definition$name = definition.name) === null ||
+        _definition$name === void 0
+          ? void 0
+          : _definition$name.value) === operationName
+      ) {
+        return definition;
+      }
+    }
+  }
+
+  return operation;
+}

package/node_modules/graphql/utilities/getOperationAST.mjs

@@ -0,0 +1,51 @@
+/** @category Operations */
+import { Kind } from '../language/kinds.mjs';
+/**
+ * Returns an operation AST given a document AST and optionally an operation
+ * name. If a name is not provided, an operation is only returned if only one is
+ * provided in the document.
+ * @param documentAST - The parsed GraphQL document AST.
+ * @param operationName - The optional operation name to select.
+ * @returns The resolved operation ast.
+ * @example
+ * ```ts
+ * import { parse } from 'graphql/language';
+ * import { getOperationAST } from 'graphql/utilities';
+ *
+ * const document = parse('query GetName { name }');
+ * const operation = getOperationAST(document, 'GetName');
+ *
+ * operation.name.value; // => 'GetName'
+ * getOperationAST(document, 'Missing'); // => undefined
+ * ```
+ */
+
+export function getOperationAST(documentAST, operationName) {
+  let operation = null;
+
+  for (const definition of documentAST.definitions) {
+    if (definition.kind === Kind.OPERATION_DEFINITION) {
+      var _definition$name;
+
+      if (operationName == null) {
+        // If no operation name was provided, only return an Operation if there
+        // is one defined in the document. Upon encountering the second, return
+        // null.
+        if (operation) {
+          return null;
+        }
+
+        operation = definition;
+      } else if (
+        ((_definition$name = definition.name) === null ||
+        _definition$name === void 0
+          ? void 0
+          : _definition$name.value) === operationName
+      ) {
+        return definition;
+      }
+    }
+  }
+
+  return operation;
+}

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

@@ -0,0 +1,32 @@
+/** @category Operations */
+import type {
+  OperationDefinitionNode,
+  OperationTypeDefinitionNode,
+} from '../language/ast';
+import type { GraphQLObjectType } from '../type/definition';
+import type { GraphQLSchema } from '../type/schema';
+/**
+ * Extracts the root type of the operation from the schema. This deprecated
+ * helper is retained for backwards compatibility; call
+ * `GraphQLSchema.getRootType` instead because getOperationRootType will be
+ * removed in v17.
+ * @param schema - GraphQL schema to use.
+ * @param operation - The operation definition to inspect.
+ * @returns The resolved operation root type.
+ * @example
+ * ```ts
+ * import { buildSchema, getOperationRootType } from 'graphql/utilities';
+ * import { parse } from 'graphql/language';
+ *
+ * const schema = buildSchema('type Query { name: String }');
+ * const operation = parse('{ name }').definitions[0];
+ * const rootType = getOperationRootType(schema, operation);
+ *
+ * rootType.name; // => 'Query'
+ * ```
+ * @deprecated Please use `GraphQLSchema.getRootType` instead. Will be removed in v17
+ */
+export declare function getOperationRootType(
+  schema: GraphQLSchema,
+  operation: OperationDefinitionNode | OperationTypeDefinitionNode,
+): GraphQLObjectType;

package/node_modules/graphql/utilities/getOperationRootType.js

@@ -0,0 +1,85 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.getOperationRootType = getOperationRootType;
+
+var _GraphQLError = require('../error/GraphQLError.js');
+
+/** @category Operations */
+
+/**
+ * Extracts the root type of the operation from the schema. This deprecated
+ * helper is retained for backwards compatibility; call
+ * `GraphQLSchema.getRootType` instead because getOperationRootType will be
+ * removed in v17.
+ * @param schema - GraphQL schema to use.
+ * @param operation - The operation definition to inspect.
+ * @returns The resolved operation root type.
+ * @example
+ * ```ts
+ * import { buildSchema, getOperationRootType } from 'graphql/utilities';
+ * import { parse } from 'graphql/language';
+ *
+ * const schema = buildSchema('type Query { name: String }');
+ * const operation = parse('{ name }').definitions[0];
+ * const rootType = getOperationRootType(schema, operation);
+ *
+ * rootType.name; // => 'Query'
+ * ```
+ * @deprecated Please use `GraphQLSchema.getRootType` instead. Will be removed in v17
+ */
+function getOperationRootType(schema, operation) {
+  if (operation.operation === 'query') {
+    const queryType = schema.getQueryType();
+
+    if (!queryType) {
+      throw new _GraphQLError.GraphQLError(
+        'Schema does not define the required query root type.',
+        {
+          nodes: operation,
+        },
+      );
+    }
+
+    return queryType;
+  }
+
+  if (operation.operation === 'mutation') {
+    const mutationType = schema.getMutationType();
+
+    if (!mutationType) {
+      throw new _GraphQLError.GraphQLError(
+        'Schema is not configured for mutations.',
+        {
+          nodes: operation,
+        },
+      );
+    }
+
+    return mutationType;
+  }
+
+  if (operation.operation === 'subscription') {
+    const subscriptionType = schema.getSubscriptionType();
+
+    if (!subscriptionType) {
+      throw new _GraphQLError.GraphQLError(
+        'Schema is not configured for subscriptions.',
+        {
+          nodes: operation,
+        },
+      );
+    }
+
+    return subscriptionType;
+  }
+
+  throw new _GraphQLError.GraphQLError(
+    'Can only have query, mutation and subscription operations.',
+    {
+      nodes: operation,
+    },
+  );
+}

package/node_modules/graphql/utilities/getOperationRootType.mjs

@@ -0,0 +1,71 @@
+/** @category Operations */
+import { GraphQLError } from '../error/GraphQLError.mjs';
+
+/**
+ * Extracts the root type of the operation from the schema. This deprecated
+ * helper is retained for backwards compatibility; call
+ * `GraphQLSchema.getRootType` instead because getOperationRootType will be
+ * removed in v17.
+ * @param schema - GraphQL schema to use.
+ * @param operation - The operation definition to inspect.
+ * @returns The resolved operation root type.
+ * @example
+ * ```ts
+ * import { buildSchema, getOperationRootType } from 'graphql/utilities';
+ * import { parse } from 'graphql/language';
+ *
+ * const schema = buildSchema('type Query { name: String }');
+ * const operation = parse('{ name }').definitions[0];
+ * const rootType = getOperationRootType(schema, operation);
+ *
+ * rootType.name; // => 'Query'
+ * ```
+ * @deprecated Please use `GraphQLSchema.getRootType` instead. Will be removed in v17
+ */
+export function getOperationRootType(schema, operation) {
+  if (operation.operation === 'query') {
+    const queryType = schema.getQueryType();
+
+    if (!queryType) {
+      throw new GraphQLError(
+        'Schema does not define the required query root type.',
+        {
+          nodes: operation,
+        },
+      );
+    }
+
+    return queryType;
+  }
+
+  if (operation.operation === 'mutation') {
+    const mutationType = schema.getMutationType();
+
+    if (!mutationType) {
+      throw new GraphQLError('Schema is not configured for mutations.', {
+        nodes: operation,
+      });
+    }
+
+    return mutationType;
+  }
+
+  if (operation.operation === 'subscription') {
+    const subscriptionType = schema.getSubscriptionType();
+
+    if (!subscriptionType) {
+      throw new GraphQLError('Schema is not configured for subscriptions.', {
+        nodes: operation,
+      });
+    }
+
+    return subscriptionType;
+  }
+
+  throw new GraphQLError(
+    'Can only have query, mutation and subscription operations.',
+    {
+      nodes: operation,
+    },
+  );
+}

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

@@ -0,0 +1,73 @@
+/**
+ * Utilities for building schemas, working with introspection, transforming ASTs,
+ * and comparing GraphQL types.
+ *
+ * These exports are also available from the root `graphql` package.
+ * @packageDocumentation
+ */
+export { getIntrospectionQuery } from './getIntrospectionQuery';
+export type {
+  IntrospectionOptions,
+  IntrospectionQuery,
+  IntrospectionSchema,
+  IntrospectionType,
+  IntrospectionInputType,
+  IntrospectionOutputType,
+  IntrospectionScalarType,
+  IntrospectionObjectType,
+  IntrospectionInterfaceType,
+  IntrospectionUnionType,
+  IntrospectionEnumType,
+  IntrospectionInputObjectType,
+  IntrospectionTypeRef,
+  IntrospectionInputTypeRef,
+  IntrospectionOutputTypeRef,
+  IntrospectionNamedTypeRef,
+  IntrospectionListTypeRef,
+  IntrospectionNonNullTypeRef,
+  IntrospectionField,
+  IntrospectionInputValue,
+  IntrospectionEnumValue,
+  IntrospectionDirective,
+} from './getIntrospectionQuery';
+export { getOperationAST } from './getOperationAST';
+export { getOperationRootType } from './getOperationRootType';
+export { introspectionFromSchema } from './introspectionFromSchema';
+export { buildClientSchema } from './buildClientSchema';
+export { buildASTSchema, buildSchema } from './buildASTSchema';
+export type { BuildSchemaOptions } from './buildASTSchema';
+export { extendSchema } from './extendSchema';
+export { lexicographicSortSchema } from './lexicographicSortSchema';
+export {
+  printSchema,
+  printType,
+  printIntrospectionSchema,
+} from './printSchema';
+export { typeFromAST } from './typeFromAST';
+export { valueFromAST } from './valueFromAST';
+export { valueFromASTUntyped } from './valueFromASTUntyped';
+export { astFromValue } from './astFromValue';
+export { TypeInfo, visitWithTypeInfo } from './TypeInfo';
+export { coerceInputValue } from './coerceInputValue';
+export { concatAST } from './concatAST';
+export { separateOperations } from './separateOperations';
+export { stripIgnoredCharacters } from './stripIgnoredCharacters';
+export {
+  isEqualType,
+  isTypeSubTypeOf,
+  doTypesOverlap,
+} from './typeComparators';
+export { assertValidName, isValidNameError } from './assertValidName';
+export {
+  BreakingChangeType,
+  DangerousChangeType,
+  findBreakingChanges,
+  findDangerousChanges,
+} from './findBreakingChanges';
+export type { BreakingChange, DangerousChange } from './findBreakingChanges';
+export type { TypedQueryDocumentNode } from './typedQueryDocumentNode';
+export {
+  resolveSchemaCoordinate,
+  resolveASTSchemaCoordinate,
+} from './resolveSchemaCoordinate';
+export type { ResolvedSchemaElement } from './resolveSchemaCoordinate';

package/node_modules/graphql/utilities/index.js

@@ -0,0 +1,247 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+Object.defineProperty(exports, 'BreakingChangeType', {
+  enumerable: true,
+  get: function () {
+    return _findBreakingChanges.BreakingChangeType;
+  },
+});
+Object.defineProperty(exports, 'DangerousChangeType', {
+  enumerable: true,
+  get: function () {
+    return _findBreakingChanges.DangerousChangeType;
+  },
+});
+Object.defineProperty(exports, 'TypeInfo', {
+  enumerable: true,
+  get: function () {
+    return _TypeInfo.TypeInfo;
+  },
+});
+Object.defineProperty(exports, 'assertValidName', {
+  enumerable: true,
+  get: function () {
+    return _assertValidName.assertValidName;
+  },
+});
+Object.defineProperty(exports, 'astFromValue', {
+  enumerable: true,
+  get: function () {
+    return _astFromValue.astFromValue;
+  },
+});
+Object.defineProperty(exports, 'buildASTSchema', {
+  enumerable: true,
+  get: function () {
+    return _buildASTSchema.buildASTSchema;
+  },
+});
+Object.defineProperty(exports, 'buildClientSchema', {
+  enumerable: true,
+  get: function () {
+    return _buildClientSchema.buildClientSchema;
+  },
+});
+Object.defineProperty(exports, 'buildSchema', {
+  enumerable: true,
+  get: function () {
+    return _buildASTSchema.buildSchema;
+  },
+});
+Object.defineProperty(exports, 'coerceInputValue', {
+  enumerable: true,
+  get: function () {
+    return _coerceInputValue.coerceInputValue;
+  },
+});
+Object.defineProperty(exports, 'concatAST', {
+  enumerable: true,
+  get: function () {
+    return _concatAST.concatAST;
+  },
+});
+Object.defineProperty(exports, 'doTypesOverlap', {
+  enumerable: true,
+  get: function () {
+    return _typeComparators.doTypesOverlap;
+  },
+});
+Object.defineProperty(exports, 'extendSchema', {
+  enumerable: true,
+  get: function () {
+    return _extendSchema.extendSchema;
+  },
+});
+Object.defineProperty(exports, 'findBreakingChanges', {
+  enumerable: true,
+  get: function () {
+    return _findBreakingChanges.findBreakingChanges;
+  },
+});
+Object.defineProperty(exports, 'findDangerousChanges', {
+  enumerable: true,
+  get: function () {
+    return _findBreakingChanges.findDangerousChanges;
+  },
+});
+Object.defineProperty(exports, 'getIntrospectionQuery', {
+  enumerable: true,
+  get: function () {
+    return _getIntrospectionQuery.getIntrospectionQuery;
+  },
+});
+Object.defineProperty(exports, 'getOperationAST', {
+  enumerable: true,
+  get: function () {
+    return _getOperationAST.getOperationAST;
+  },
+});
+Object.defineProperty(exports, 'getOperationRootType', {
+  enumerable: true,
+  get: function () {
+    return _getOperationRootType.getOperationRootType;
+  },
+});
+Object.defineProperty(exports, 'introspectionFromSchema', {
+  enumerable: true,
+  get: function () {
+    return _introspectionFromSchema.introspectionFromSchema;
+  },
+});
+Object.defineProperty(exports, 'isEqualType', {
+  enumerable: true,
+  get: function () {
+    return _typeComparators.isEqualType;
+  },
+});
+Object.defineProperty(exports, 'isTypeSubTypeOf', {
+  enumerable: true,
+  get: function () {
+    return _typeComparators.isTypeSubTypeOf;
+  },
+});
+Object.defineProperty(exports, 'isValidNameError', {
+  enumerable: true,
+  get: function () {
+    return _assertValidName.isValidNameError;
+  },
+});
+Object.defineProperty(exports, 'lexicographicSortSchema', {
+  enumerable: true,
+  get: function () {
+    return _lexicographicSortSchema.lexicographicSortSchema;
+  },
+});
+Object.defineProperty(exports, 'printIntrospectionSchema', {
+  enumerable: true,
+  get: function () {
+    return _printSchema.printIntrospectionSchema;
+  },
+});
+Object.defineProperty(exports, 'printSchema', {
+  enumerable: true,
+  get: function () {
+    return _printSchema.printSchema;
+  },
+});
+Object.defineProperty(exports, 'printType', {
+  enumerable: true,
+  get: function () {
+    return _printSchema.printType;
+  },
+});
+Object.defineProperty(exports, 'resolveASTSchemaCoordinate', {
+  enumerable: true,
+  get: function () {
+    return _resolveSchemaCoordinate.resolveASTSchemaCoordinate;
+  },
+});
+Object.defineProperty(exports, 'resolveSchemaCoordinate', {
+  enumerable: true,
+  get: function () {
+    return _resolveSchemaCoordinate.resolveSchemaCoordinate;
+  },
+});
+Object.defineProperty(exports, 'separateOperations', {
+  enumerable: true,
+  get: function () {
+    return _separateOperations.separateOperations;
+  },
+});
+Object.defineProperty(exports, 'stripIgnoredCharacters', {
+  enumerable: true,
+  get: function () {
+    return _stripIgnoredCharacters.stripIgnoredCharacters;
+  },
+});
+Object.defineProperty(exports, 'typeFromAST', {
+  enumerable: true,
+  get: function () {
+    return _typeFromAST.typeFromAST;
+  },
+});
+Object.defineProperty(exports, 'valueFromAST', {
+  enumerable: true,
+  get: function () {
+    return _valueFromAST.valueFromAST;
+  },
+});
+Object.defineProperty(exports, 'valueFromASTUntyped', {
+  enumerable: true,
+  get: function () {
+    return _valueFromASTUntyped.valueFromASTUntyped;
+  },
+});
+Object.defineProperty(exports, 'visitWithTypeInfo', {
+  enumerable: true,
+  get: function () {
+    return _TypeInfo.visitWithTypeInfo;
+  },
+});
+
+var _getIntrospectionQuery = require('./getIntrospectionQuery.js');
+
+var _getOperationAST = require('./getOperationAST.js');
+
+var _getOperationRootType = require('./getOperationRootType.js');
+
+var _introspectionFromSchema = require('./introspectionFromSchema.js');
+
+var _buildClientSchema = require('./buildClientSchema.js');
+
+var _buildASTSchema = require('./buildASTSchema.js');
+
+var _extendSchema = require('./extendSchema.js');
+
+var _lexicographicSortSchema = require('./lexicographicSortSchema.js');
+
+var _printSchema = require('./printSchema.js');
+
+var _typeFromAST = require('./typeFromAST.js');
+
+var _valueFromAST = require('./valueFromAST.js');
+
+var _valueFromASTUntyped = require('./valueFromASTUntyped.js');
+
+var _astFromValue = require('./astFromValue.js');
+
+var _TypeInfo = require('./TypeInfo.js');
+
+var _coerceInputValue = require('./coerceInputValue.js');
+
+var _concatAST = require('./concatAST.js');
+
+var _separateOperations = require('./separateOperations.js');
+
+var _stripIgnoredCharacters = require('./stripIgnoredCharacters.js');
+
+var _typeComparators = require('./typeComparators.js');
+
+var _assertValidName = require('./assertValidName.js');
+
+var _findBreakingChanges = require('./findBreakingChanges.js');
+
+var _resolveSchemaCoordinate = require('./resolveSchemaCoordinate.js');