@pome-sh/cli 0.3.0 → 0.4.0

package/node_modules/graphql/utilities/index.mjs

@@ -0,0 +1,67 @@
+/**
+ * Utilities for building schemas, working with introspection, transforming ASTs,
+ * and comparing GraphQL types.
+ *
+ * These exports are also available from the root `graphql` package.
+ * @packageDocumentation
+ */
+// Produce the GraphQL query recommended for a full schema introspection.
+export { getIntrospectionQuery } from './getIntrospectionQuery.mjs';
+// Gets the target Operation from a Document.
+export { getOperationAST } from './getOperationAST.mjs'; // Gets the Type for the target Operation AST.
+
+export { getOperationRootType } from './getOperationRootType.mjs'; // Convert a GraphQLSchema to an IntrospectionQuery.
+
+export { introspectionFromSchema } from './introspectionFromSchema.mjs'; // Build a GraphQLSchema from an introspection result.
+
+export { buildClientSchema } from './buildClientSchema.mjs'; // Build a GraphQLSchema from GraphQL Schema language.
+
+export { buildASTSchema, buildSchema } from './buildASTSchema.mjs';
+// Extends an existing GraphQLSchema from a parsed GraphQL Schema language AST.
+export { extendSchema } from './extendSchema.mjs'; // Sort a GraphQLSchema.
+
+export { lexicographicSortSchema } from './lexicographicSortSchema.mjs'; // Print a GraphQLSchema to GraphQL Schema language.
+
+export {
+  printSchema,
+  printType,
+  printIntrospectionSchema,
+} from './printSchema.mjs'; // Create a GraphQLType from a GraphQL language AST.
+
+export { typeFromAST } from './typeFromAST.mjs'; // Create a JavaScript value from a GraphQL language AST with a type.
+
+export { valueFromAST } from './valueFromAST.mjs'; // Create a JavaScript value from a GraphQL language AST without a type.
+
+export { valueFromASTUntyped } from './valueFromASTUntyped.mjs'; // Create a GraphQL language AST from a JavaScript value.
+
+export { astFromValue } from './astFromValue.mjs'; // A helper to use within recursive-descent visitors which need to be aware of the GraphQL type system.
+
+export { TypeInfo, visitWithTypeInfo } from './TypeInfo.mjs'; // Coerces a JavaScript value to a GraphQL type, or produces errors.
+
+export { coerceInputValue } from './coerceInputValue.mjs'; // Concatenates multiple AST together.
+
+export { concatAST } from './concatAST.mjs'; // Separates an AST into an AST per Operation.
+
+export { separateOperations } from './separateOperations.mjs'; // Strips characters that are not significant to the validity or execution of a GraphQL document.
+
+export { stripIgnoredCharacters } from './stripIgnoredCharacters.mjs'; // Comparators for types
+
+export {
+  isEqualType,
+  isTypeSubTypeOf,
+  doTypesOverlap,
+} from './typeComparators.mjs'; // Asserts that a string is a valid GraphQL name
+
+export { assertValidName, isValidNameError } from './assertValidName.mjs'; // Compares two GraphQLSchemas and detects breaking changes.
+
+export {
+  BreakingChangeType,
+  DangerousChangeType,
+  findBreakingChanges,
+  findDangerousChanges,
+} from './findBreakingChanges.mjs';
+// Schema coordinates
+export {
+  resolveSchemaCoordinate,
+  resolveASTSchemaCoordinate,
+} from './resolveSchemaCoordinate.mjs';

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

@@ -0,0 +1,72 @@
+/** @category Introspection */
+import type { GraphQLSchema } from '../type/schema';
+import type {
+  IntrospectionOptions,
+  IntrospectionQuery,
+} from './getIntrospectionQuery';
+/**
+ * Build an IntrospectionQuery from a GraphQLSchema
+ *
+ * IntrospectionQuery is useful for utilities that care about type and field
+ * relationships, but do not need to traverse through those relationships.
+ *
+ * This is the inverse of buildClientSchema. The primary use case is outside
+ * of the server context, for instance when doing schema comparisons.
+ * @param schema - GraphQL schema to use.
+ * @param options - Optional configuration for this operation.
+ * @returns Introspection result data for the schema.
+ * @example
+ * ```ts
+ * // Include schema metadata using the default introspection options.
+ * import { buildSchema, introspectionFromSchema } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   scalar Url @specifiedBy(url: "https://url.spec.whatwg.org/")
+ *
+ *   type Query {
+ *     homepage: Url
+ *   }
+ * `);
+ *
+ * const introspection = introspectionFromSchema(schema);
+ * const urlType = introspection.__schema.types.find((type) => type.name === 'Url');
+ *
+ * urlType.specifiedByURL; // => 'https://url.spec.whatwg.org/'
+ * ```
+ * @example
+ * ```ts
+ * // This variant disables optional introspection metadata.
+ * import { buildSchema, introspectionFromSchema } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   scalar Url @specifiedBy(url: "https://url.spec.whatwg.org/")
+ *
+ *   type Query {
+ *     homepage: Url
+ *   }
+ * `);
+ *
+ * const introspection = introspectionFromSchema(schema, {
+ *   descriptions: false,
+ *   specifiedByUrl: false,
+ *   directiveIsRepeatable: false,
+ *   schemaDescription: false,
+ *   inputValueDeprecation: false,
+ *   experimentalDirectiveDeprecation: false,
+ *   oneOf: false,
+ * });
+ * const urlType = introspection.__schema.types.find((type) => type.name === 'Url');
+ * const deprecatedDirective = introspection.__schema.directives.find(
+ *   (directive) => directive.name === 'deprecated',
+ * );
+ *
+ * urlType.specifiedByURL; // => undefined
+ * urlType.description; // => undefined
+ * introspection.__schema.description; // => undefined
+ * deprecatedDirective.isRepeatable; // => undefined
+ * ```
+ */
+export declare function introspectionFromSchema(
+  schema: GraphQLSchema,
+  options?: IntrospectionOptions,
+): IntrospectionQuery;

package/node_modules/graphql/utilities/introspectionFromSchema.js

@@ -0,0 +1,99 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.introspectionFromSchema = introspectionFromSchema;
+
+var _invariant = require('../jsutils/invariant.js');
+
+var _parser = require('../language/parser.js');
+
+var _execute = require('../execution/execute.js');
+
+var _getIntrospectionQuery = require('./getIntrospectionQuery.js');
+
+/** @category Introspection */
+
+/**
+ * Build an IntrospectionQuery from a GraphQLSchema
+ *
+ * IntrospectionQuery is useful for utilities that care about type and field
+ * relationships, but do not need to traverse through those relationships.
+ *
+ * This is the inverse of buildClientSchema. The primary use case is outside
+ * of the server context, for instance when doing schema comparisons.
+ * @param schema - GraphQL schema to use.
+ * @param options - Optional configuration for this operation.
+ * @returns Introspection result data for the schema.
+ * @example
+ * ```ts
+ * // Include schema metadata using the default introspection options.
+ * import { buildSchema, introspectionFromSchema } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   scalar Url @specifiedBy(url: "https://url.spec.whatwg.org/")
+ *
+ *   type Query {
+ *     homepage: Url
+ *   }
+ * `);
+ *
+ * const introspection = introspectionFromSchema(schema);
+ * const urlType = introspection.__schema.types.find((type) => type.name === 'Url');
+ *
+ * urlType.specifiedByURL; // => 'https://url.spec.whatwg.org/'
+ * ```
+ * @example
+ * ```ts
+ * // This variant disables optional introspection metadata.
+ * import { buildSchema, introspectionFromSchema } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   scalar Url @specifiedBy(url: "https://url.spec.whatwg.org/")
+ *
+ *   type Query {
+ *     homepage: Url
+ *   }
+ * `);
+ *
+ * const introspection = introspectionFromSchema(schema, {
+ *   descriptions: false,
+ *   specifiedByUrl: false,
+ *   directiveIsRepeatable: false,
+ *   schemaDescription: false,
+ *   inputValueDeprecation: false,
+ *   experimentalDirectiveDeprecation: false,
+ *   oneOf: false,
+ * });
+ * const urlType = introspection.__schema.types.find((type) => type.name === 'Url');
+ * const deprecatedDirective = introspection.__schema.directives.find(
+ *   (directive) => directive.name === 'deprecated',
+ * );
+ *
+ * urlType.specifiedByURL; // => undefined
+ * urlType.description; // => undefined
+ * introspection.__schema.description; // => undefined
+ * deprecatedDirective.isRepeatable; // => undefined
+ * ```
+ */
+function introspectionFromSchema(schema, options) {
+  const optionsWithDefaults = {
+    specifiedByUrl: true,
+    directiveIsRepeatable: true,
+    schemaDescription: true,
+    inputValueDeprecation: true,
+    experimentalDirectiveDeprecation: true,
+    oneOf: true,
+    ...options,
+  };
+  const document = (0, _parser.parse)(
+    (0, _getIntrospectionQuery.getIntrospectionQuery)(optionsWithDefaults),
+  );
+  const result = (0, _execute.executeSync)({
+    schema,
+    document,
+  });
+  (!result.errors && result.data) || (0, _invariant.invariant)(false);
+  return result.data;
+}

package/node_modules/graphql/utilities/introspectionFromSchema.mjs

@@ -0,0 +1,86 @@
+/** @category Introspection */
+import { invariant } from '../jsutils/invariant.mjs';
+import { parse } from '../language/parser.mjs';
+import { executeSync } from '../execution/execute.mjs';
+import { getIntrospectionQuery } from './getIntrospectionQuery.mjs';
+/**
+ * Build an IntrospectionQuery from a GraphQLSchema
+ *
+ * IntrospectionQuery is useful for utilities that care about type and field
+ * relationships, but do not need to traverse through those relationships.
+ *
+ * This is the inverse of buildClientSchema. The primary use case is outside
+ * of the server context, for instance when doing schema comparisons.
+ * @param schema - GraphQL schema to use.
+ * @param options - Optional configuration for this operation.
+ * @returns Introspection result data for the schema.
+ * @example
+ * ```ts
+ * // Include schema metadata using the default introspection options.
+ * import { buildSchema, introspectionFromSchema } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   scalar Url @specifiedBy(url: "https://url.spec.whatwg.org/")
+ *
+ *   type Query {
+ *     homepage: Url
+ *   }
+ * `);
+ *
+ * const introspection = introspectionFromSchema(schema);
+ * const urlType = introspection.__schema.types.find((type) => type.name === 'Url');
+ *
+ * urlType.specifiedByURL; // => 'https://url.spec.whatwg.org/'
+ * ```
+ * @example
+ * ```ts
+ * // This variant disables optional introspection metadata.
+ * import { buildSchema, introspectionFromSchema } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   scalar Url @specifiedBy(url: "https://url.spec.whatwg.org/")
+ *
+ *   type Query {
+ *     homepage: Url
+ *   }
+ * `);
+ *
+ * const introspection = introspectionFromSchema(schema, {
+ *   descriptions: false,
+ *   specifiedByUrl: false,
+ *   directiveIsRepeatable: false,
+ *   schemaDescription: false,
+ *   inputValueDeprecation: false,
+ *   experimentalDirectiveDeprecation: false,
+ *   oneOf: false,
+ * });
+ * const urlType = introspection.__schema.types.find((type) => type.name === 'Url');
+ * const deprecatedDirective = introspection.__schema.directives.find(
+ *   (directive) => directive.name === 'deprecated',
+ * );
+ *
+ * urlType.specifiedByURL; // => undefined
+ * urlType.description; // => undefined
+ * introspection.__schema.description; // => undefined
+ * deprecatedDirective.isRepeatable; // => undefined
+ * ```
+ */
+
+export function introspectionFromSchema(schema, options) {
+  const optionsWithDefaults = {
+    specifiedByUrl: true,
+    directiveIsRepeatable: true,
+    schemaDescription: true,
+    inputValueDeprecation: true,
+    experimentalDirectiveDeprecation: true,
+    oneOf: true,
+    ...options,
+  };
+  const document = parse(getIntrospectionQuery(optionsWithDefaults));
+  const result = executeSync({
+    schema,
+    document,
+  });
+  (!result.errors && result.data) || invariant(false);
+  return result.data;
+}

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

@@ -0,0 +1,44 @@
+/** @category Schema Construction */
+import { GraphQLSchema } from '../type/schema';
+/**
+ * Sort GraphQLSchema.
+ *
+ * This function returns a sorted copy of the given GraphQLSchema.
+ * @param schema - GraphQL schema to use.
+ * @returns A copy of the schema with types, fields, arguments, and values sorted lexicographically.
+ * @example
+ * ```ts
+ * import { buildSchema, lexicographicSortSchema, printSchema } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     zebra: String
+ *     apple: String
+ *   }
+ *
+ *   enum Episode {
+ *     JEDI
+ *     NEW_HOPE
+ *     EMPIRE
+ *   }
+ * `);
+ *
+ * const sortedSchema = lexicographicSortSchema(schema);
+ *
+ * printSchema(sortedSchema);
+ * // =>
+ * // enum Episode {
+ * //   EMPIRE
+ * //   JEDI
+ * //   NEW_HOPE
+ * // }
+ * //
+ * // type Query {
+ * //   apple: String
+ * //   zebra: String
+ * // }
+ * ```
+ */
+export declare function lexicographicSortSchema(
+  schema: GraphQLSchema,
+): GraphQLSchema;

package/node_modules/graphql/utilities/lexicographicSortSchema.js

@@ -0,0 +1,213 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.lexicographicSortSchema = lexicographicSortSchema;
+
+var _inspect = require('../jsutils/inspect.js');
+
+var _invariant = require('../jsutils/invariant.js');
+
+var _keyValMap = require('../jsutils/keyValMap.js');
+
+var _naturalCompare = require('../jsutils/naturalCompare.js');
+
+var _definition = require('../type/definition.js');
+
+var _directives = require('../type/directives.js');
+
+var _introspection = require('../type/introspection.js');
+
+var _schema = require('../type/schema.js');
+
+/** @category Schema Construction */
+
+/**
+ * Sort GraphQLSchema.
+ *
+ * This function returns a sorted copy of the given GraphQLSchema.
+ * @param schema - GraphQL schema to use.
+ * @returns A copy of the schema with types, fields, arguments, and values sorted lexicographically.
+ * @example
+ * ```ts
+ * import { buildSchema, lexicographicSortSchema, printSchema } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     zebra: String
+ *     apple: String
+ *   }
+ *
+ *   enum Episode {
+ *     JEDI
+ *     NEW_HOPE
+ *     EMPIRE
+ *   }
+ * `);
+ *
+ * const sortedSchema = lexicographicSortSchema(schema);
+ *
+ * printSchema(sortedSchema);
+ * // =>
+ * // enum Episode {
+ * //   EMPIRE
+ * //   JEDI
+ * //   NEW_HOPE
+ * // }
+ * //
+ * // type Query {
+ * //   apple: String
+ * //   zebra: String
+ * // }
+ * ```
+ */
+function lexicographicSortSchema(schema) {
+  const schemaConfig = schema.toConfig();
+  const typeMap = (0, _keyValMap.keyValMap)(
+    sortByName(schemaConfig.types),
+    (type) => type.name,
+    sortNamedType,
+  );
+  return new _schema.GraphQLSchema({
+    ...schemaConfig,
+    types: Object.values(typeMap),
+    directives: sortByName(schemaConfig.directives).map(sortDirective),
+    query: replaceMaybeType(schemaConfig.query),
+    mutation: replaceMaybeType(schemaConfig.mutation),
+    subscription: replaceMaybeType(schemaConfig.subscription),
+  });
+
+  function replaceType(type) {
+    if ((0, _definition.isListType)(type)) {
+      // @ts-expect-error
+      return new _definition.GraphQLList(replaceType(type.ofType));
+    } else if ((0, _definition.isNonNullType)(type)) {
+      // @ts-expect-error
+      return new _definition.GraphQLNonNull(replaceType(type.ofType));
+    } // @ts-expect-error FIXME: TS Conversion
+
+    return replaceNamedType(type);
+  }
+
+  function replaceNamedType(type) {
+    return typeMap[type.name];
+  }
+
+  function replaceMaybeType(maybeType) {
+    return maybeType && replaceNamedType(maybeType);
+  }
+
+  function sortDirective(directive) {
+    const config = directive.toConfig();
+    return new _directives.GraphQLDirective({
+      ...config,
+      locations: sortBy(config.locations, (x) => x),
+      args: sortArgs(config.args),
+    });
+  }
+
+  function sortArgs(args) {
+    return sortObjMap(args, (arg) => ({ ...arg, type: replaceType(arg.type) }));
+  }
+
+  function sortFields(fieldsMap) {
+    return sortObjMap(fieldsMap, (field) => ({
+      ...field,
+      type: replaceType(field.type),
+      args: field.args && sortArgs(field.args),
+    }));
+  }
+
+  function sortInputFields(fieldsMap) {
+    return sortObjMap(fieldsMap, (field) => ({
+      ...field,
+      type: replaceType(field.type),
+    }));
+  }
+
+  function sortTypes(array) {
+    return sortByName(array).map(replaceNamedType);
+  }
+
+  function sortNamedType(type) {
+    if (
+      (0, _definition.isScalarType)(type) ||
+      (0, _introspection.isIntrospectionType)(type)
+    ) {
+      return type;
+    }
+
+    if ((0, _definition.isObjectType)(type)) {
+      const config = type.toConfig();
+      return new _definition.GraphQLObjectType({
+        ...config,
+        interfaces: () => sortTypes(config.interfaces),
+        fields: () => sortFields(config.fields),
+      });
+    }
+
+    if ((0, _definition.isInterfaceType)(type)) {
+      const config = type.toConfig();
+      return new _definition.GraphQLInterfaceType({
+        ...config,
+        interfaces: () => sortTypes(config.interfaces),
+        fields: () => sortFields(config.fields),
+      });
+    }
+
+    if ((0, _definition.isUnionType)(type)) {
+      const config = type.toConfig();
+      return new _definition.GraphQLUnionType({
+        ...config,
+        types: () => sortTypes(config.types),
+      });
+    }
+
+    if ((0, _definition.isEnumType)(type)) {
+      const config = type.toConfig();
+      return new _definition.GraphQLEnumType({
+        ...config,
+        values: sortObjMap(config.values, (value) => value),
+      });
+    }
+
+    if ((0, _definition.isInputObjectType)(type)) {
+      const config = type.toConfig();
+      return new _definition.GraphQLInputObjectType({
+        ...config,
+        fields: () => sortInputFields(config.fields),
+      });
+    }
+    /* c8 ignore next 3 */
+    // Not reachable, all possible types have been considered.
+
+    false ||
+      (0, _invariant.invariant)(
+        false,
+        'Unexpected type: ' + (0, _inspect.inspect)(type),
+      );
+  }
+}
+
+function sortObjMap(map, sortValueFn) {
+  const sortedMap = Object.create(null);
+
+  for (const key of Object.keys(map).sort(_naturalCompare.naturalCompare)) {
+    sortedMap[key] = sortValueFn(map[key]);
+  }
+
+  return sortedMap;
+}
+
+function sortByName(array) {
+  return sortBy(array, (obj) => obj.name);
+}
+
+function sortBy(array, mapToKey) {
+  return array.slice().sort((obj1, obj2) => {
+    const key1 = mapToKey(obj1);
+    const key2 = mapToKey(obj2);
+    return (0, _naturalCompare.naturalCompare)(key1, key2);
+  });
+}