@pome-sh/cli 0.2.0 → 0.4.0

package/node_modules/graphql/utilities/lexicographicSortSchema.mjs

@@ -0,0 +1,207 @@
+/** @category Schema Construction */
+import { inspect } from '../jsutils/inspect.mjs';
+import { invariant } from '../jsutils/invariant.mjs';
+import { keyValMap } from '../jsutils/keyValMap.mjs';
+import { naturalCompare } from '../jsutils/naturalCompare.mjs';
+import {
+  GraphQLEnumType,
+  GraphQLInputObjectType,
+  GraphQLInterfaceType,
+  GraphQLList,
+  GraphQLNonNull,
+  GraphQLObjectType,
+  GraphQLUnionType,
+  isEnumType,
+  isInputObjectType,
+  isInterfaceType,
+  isListType,
+  isNonNullType,
+  isObjectType,
+  isScalarType,
+  isUnionType,
+} from '../type/definition.mjs';
+import { GraphQLDirective } from '../type/directives.mjs';
+import { isIntrospectionType } from '../type/introspection.mjs';
+import { GraphQLSchema } from '../type/schema.mjs';
+/**
+ * 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 function lexicographicSortSchema(schema) {
+  const schemaConfig = schema.toConfig();
+  const typeMap = keyValMap(
+    sortByName(schemaConfig.types),
+    (type) => type.name,
+    sortNamedType,
+  );
+  return new 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 (isListType(type)) {
+      // @ts-expect-error
+      return new GraphQLList(replaceType(type.ofType));
+    } else if (isNonNullType(type)) {
+      // @ts-expect-error
+      return new 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 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 (isScalarType(type) || isIntrospectionType(type)) {
+      return type;
+    }
+
+    if (isObjectType(type)) {
+      const config = type.toConfig();
+      return new GraphQLObjectType({
+        ...config,
+        interfaces: () => sortTypes(config.interfaces),
+        fields: () => sortFields(config.fields),
+      });
+    }
+
+    if (isInterfaceType(type)) {
+      const config = type.toConfig();
+      return new GraphQLInterfaceType({
+        ...config,
+        interfaces: () => sortTypes(config.interfaces),
+        fields: () => sortFields(config.fields),
+      });
+    }
+
+    if (isUnionType(type)) {
+      const config = type.toConfig();
+      return new GraphQLUnionType({
+        ...config,
+        types: () => sortTypes(config.types),
+      });
+    }
+
+    if (isEnumType(type)) {
+      const config = type.toConfig();
+      return new GraphQLEnumType({
+        ...config,
+        values: sortObjMap(config.values, (value) => value),
+      });
+    }
+
+    if (isInputObjectType(type)) {
+      const config = type.toConfig();
+      return new GraphQLInputObjectType({
+        ...config,
+        fields: () => sortInputFields(config.fields),
+      });
+    }
+    /* c8 ignore next 3 */
+    // Not reachable, all possible types have been considered.
+
+    false || invariant(false, 'Unexpected type: ' + inspect(type));
+  }
+}
+
+function sortObjMap(map, sortValueFn) {
+  const sortedMap = Object.create(null);
+
+  for (const key of Object.keys(map).sort(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 naturalCompare(key1, key2);
+  });
+}

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

@@ -0,0 +1,68 @@
+/** @category Schema Printing */
+import type { GraphQLNamedType } from '../type/definition';
+import type { GraphQLSchema } from '../type/schema';
+/**
+ * Prints the schema.
+ * @param schema - GraphQL schema to use.
+ * @returns The printed string representation.
+ * @example
+ * ```ts
+ * import { buildSchema, printSchema } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   directive @upper on FIELD_DEFINITION
+ *
+ *   type Query {
+ *     greeting: String @upper
+ *   }
+ * `);
+ *
+ * printSchema(schema); // => ['directive @upper on FIELD_DEFINITION', '', 'type Query {', '  greeting: String', '}'].join('\n')
+ * ```
+ */
+export declare function printSchema(schema: GraphQLSchema): string;
+/**
+ * Prints the introspection schema.
+ * @param schema - GraphQL schema to use.
+ * @returns The printed string representation.
+ * @example
+ * ```ts
+ * import { buildSchema, printIntrospectionSchema } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     greeting: String
+ *   }
+ * `);
+ *
+ * const printed = printIntrospectionSchema(schema);
+ *
+ * printed; // matches /type __Schema/
+ * printed; // matches /enum __TypeKind/
+ * printed; // does not match /type Query/
+ * ```
+ */
+export declare function printIntrospectionSchema(schema: GraphQLSchema): string;
+/**
+ * Prints the type.
+ * @param type - The GraphQL type to inspect.
+ * @returns The printed string representation.
+ * @example
+ * ```ts
+ * import { buildSchema, printType } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   type User {
+ *     id: ID!
+ *     name: String
+ *   }
+ *
+ *   type Query {
+ *     viewer: User
+ *   }
+ * `);
+ *
+ * printType(schema.getType('User')); // => ['type User {', '  id: ID!', '  name: String', '}'].join('\n')
+ * ```
+ */
+export declare function printType(type: GraphQLNamedType): string;

package/node_modules/graphql/utilities/printSchema.js

@@ -0,0 +1,405 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.printIntrospectionSchema = printIntrospectionSchema;
+exports.printSchema = printSchema;
+exports.printType = printType;
+
+var _inspect = require('../jsutils/inspect.js');
+
+var _invariant = require('../jsutils/invariant.js');
+
+var _blockString = require('../language/blockString.js');
+
+var _kinds = require('../language/kinds.js');
+
+var _printer = require('../language/printer.js');
+
+var _definition = require('../type/definition.js');
+
+var _directives = require('../type/directives.js');
+
+var _introspection = require('../type/introspection.js');
+
+var _scalars = require('../type/scalars.js');
+
+var _astFromValue = require('./astFromValue.js');
+
+/** @category Schema Printing */
+
+/**
+ * Prints the schema.
+ * @param schema - GraphQL schema to use.
+ * @returns The printed string representation.
+ * @example
+ * ```ts
+ * import { buildSchema, printSchema } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   directive @upper on FIELD_DEFINITION
+ *
+ *   type Query {
+ *     greeting: String @upper
+ *   }
+ * `);
+ *
+ * printSchema(schema); // => ['directive @upper on FIELD_DEFINITION', '', 'type Query {', '  greeting: String', '}'].join('\n')
+ * ```
+ */
+function printSchema(schema) {
+  return printFilteredSchema(
+    schema,
+    (n) => !(0, _directives.isSpecifiedDirective)(n),
+    isDefinedType,
+  );
+}
+/**
+ * Prints the introspection schema.
+ * @param schema - GraphQL schema to use.
+ * @returns The printed string representation.
+ * @example
+ * ```ts
+ * import { buildSchema, printIntrospectionSchema } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     greeting: String
+ *   }
+ * `);
+ *
+ * const printed = printIntrospectionSchema(schema);
+ *
+ * printed; // matches /type __Schema/
+ * printed; // matches /enum __TypeKind/
+ * printed; // does not match /type Query/
+ * ```
+ */
+
+function printIntrospectionSchema(schema) {
+  return printFilteredSchema(
+    schema,
+    _directives.isSpecifiedDirective,
+    _introspection.isIntrospectionType,
+  );
+}
+
+function isDefinedType(type) {
+  return (
+    !(0, _scalars.isSpecifiedScalarType)(type) &&
+    !(0, _introspection.isIntrospectionType)(type)
+  );
+}
+
+function printFilteredSchema(schema, directiveFilter, typeFilter) {
+  const directives = schema.getDirectives().filter(directiveFilter);
+  const types = Object.values(schema.getTypeMap()).filter(typeFilter);
+  return [
+    printSchemaDefinition(schema),
+    ...directives.map((directive) => printDirective(directive)),
+    ...types.map((type) => printType(type)),
+  ]
+    .filter(Boolean)
+    .join('\n\n');
+}
+
+function printSchemaDefinition(schema) {
+  if (schema.description == null && isSchemaOfCommonNames(schema)) {
+    return;
+  }
+
+  const operationTypes = [];
+  const queryType = schema.getQueryType();
+
+  if (queryType) {
+    operationTypes.push(`  query: ${queryType.name}`);
+  }
+
+  const mutationType = schema.getMutationType();
+
+  if (mutationType) {
+    operationTypes.push(`  mutation: ${mutationType.name}`);
+  }
+
+  const subscriptionType = schema.getSubscriptionType();
+
+  if (subscriptionType) {
+    operationTypes.push(`  subscription: ${subscriptionType.name}`);
+  }
+
+  return printDescription(schema) + `schema {\n${operationTypes.join('\n')}\n}`;
+}
+/**
+ * GraphQL schema define root types for each type of operation. These types are
+ * the same as any other type and can be named in any manner, however there is
+ * a common naming convention:
+ *
+ * ```graphql
+ *   schema {
+ *     query: Query
+ *     mutation: Mutation
+ *     subscription: Subscription
+ *   }
+ * ```
+ *
+ * When using this naming convention, the schema description can be omitted.
+ *
+ * @internal
+ */
+
+function isSchemaOfCommonNames(schema) {
+  const queryType = schema.getQueryType();
+
+  if (queryType && queryType.name !== 'Query') {
+    return false;
+  }
+
+  const mutationType = schema.getMutationType();
+
+  if (mutationType && mutationType.name !== 'Mutation') {
+    return false;
+  }
+
+  const subscriptionType = schema.getSubscriptionType();
+
+  if (subscriptionType && subscriptionType.name !== 'Subscription') {
+    return false;
+  }
+
+  return true;
+}
+/**
+ * Prints the type.
+ * @param type - The GraphQL type to inspect.
+ * @returns The printed string representation.
+ * @example
+ * ```ts
+ * import { buildSchema, printType } from 'graphql/utilities';
+ *
+ * const schema = buildSchema(`
+ *   type User {
+ *     id: ID!
+ *     name: String
+ *   }
+ *
+ *   type Query {
+ *     viewer: User
+ *   }
+ * `);
+ *
+ * printType(schema.getType('User')); // => ['type User {', '  id: ID!', '  name: String', '}'].join('\n')
+ * ```
+ */
+
+function printType(type) {
+  if ((0, _definition.isScalarType)(type)) {
+    return printScalar(type);
+  }
+
+  if ((0, _definition.isObjectType)(type)) {
+    return printObject(type);
+  }
+
+  if ((0, _definition.isInterfaceType)(type)) {
+    return printInterface(type);
+  }
+
+  if ((0, _definition.isUnionType)(type)) {
+    return printUnion(type);
+  }
+
+  if ((0, _definition.isEnumType)(type)) {
+    return printEnum(type);
+  }
+
+  if ((0, _definition.isInputObjectType)(type)) {
+    return printInputObject(type);
+  }
+  /* c8 ignore next 3 */
+  // Not reachable, all possible types have been considered.
+
+  false ||
+    (0, _invariant.invariant)(
+      false,
+      'Unexpected type: ' + (0, _inspect.inspect)(type),
+    );
+}
+
+function printScalar(type) {
+  return (
+    printDescription(type) + `scalar ${type.name}` + printSpecifiedByURL(type)
+  );
+}
+
+function printImplementedInterfaces(type) {
+  const interfaces = type.getInterfaces();
+  return interfaces.length
+    ? ' implements ' + interfaces.map((i) => i.name).join(' & ')
+    : '';
+}
+
+function printObject(type) {
+  return (
+    printDescription(type) +
+    `type ${type.name}` +
+    printImplementedInterfaces(type) +
+    printFields(type)
+  );
+}
+
+function printInterface(type) {
+  return (
+    printDescription(type) +
+    `interface ${type.name}` +
+    printImplementedInterfaces(type) +
+    printFields(type)
+  );
+}
+
+function printUnion(type) {
+  const types = type.getTypes();
+  const possibleTypes = types.length ? ' = ' + types.join(' | ') : '';
+  return printDescription(type) + 'union ' + type.name + possibleTypes;
+}
+
+function printEnum(type) {
+  const values = type
+    .getValues()
+    .map(
+      (value, i) =>
+        printDescription(value, '  ', !i) +
+        '  ' +
+        value.name +
+        printDeprecated(value.deprecationReason),
+    );
+  return printDescription(type) + `enum ${type.name}` + printBlock(values);
+}
+
+function printInputObject(type) {
+  const fields = Object.values(type.getFields()).map(
+    (f, i) => printDescription(f, '  ', !i) + '  ' + printInputValue(f),
+  );
+  return (
+    printDescription(type) +
+    `input ${type.name}` +
+    (type.isOneOf ? ' @oneOf' : '') +
+    printBlock(fields)
+  );
+}
+
+function printFields(type) {
+  const fields = Object.values(type.getFields()).map(
+    (f, i) =>
+      printDescription(f, '  ', !i) +
+      '  ' +
+      f.name +
+      printArgs(f.args, '  ') +
+      ': ' +
+      String(f.type) +
+      printDeprecated(f.deprecationReason),
+  );
+  return printBlock(fields);
+}
+
+function printBlock(items) {
+  return items.length !== 0 ? ' {\n' + items.join('\n') + '\n}' : '';
+}
+
+function printArgs(args, indentation = '') {
+  if (args.length === 0) {
+    return '';
+  } // If every arg does not have a description, print them on one line.
+
+  if (args.every((arg) => !arg.description)) {
+    return '(' + args.map(printInputValue).join(', ') + ')';
+  }
+
+  return (
+    '(\n' +
+    args
+      .map(
+        (arg, i) =>
+          printDescription(arg, '  ' + indentation, !i) +
+          '  ' +
+          indentation +
+          printInputValue(arg),
+      )
+      .join('\n') +
+    '\n' +
+    indentation +
+    ')'
+  );
+}
+
+function printInputValue(arg) {
+  const defaultAST = (0, _astFromValue.astFromValue)(
+    arg.defaultValue,
+    arg.type,
+  );
+  let argDecl = arg.name + ': ' + String(arg.type);
+
+  if (defaultAST) {
+    argDecl += ` = ${(0, _printer.print)(defaultAST)}`;
+  }
+
+  return argDecl + printDeprecated(arg.deprecationReason);
+}
+
+function printDirective(directive) {
+  return (
+    printDescription(directive) +
+    'directive @' +
+    directive.name +
+    printArgs(directive.args) +
+    printDeprecated(directive.deprecationReason) +
+    (directive.isRepeatable ? ' repeatable' : '') +
+    ' on ' +
+    directive.locations.join(' | ')
+  );
+}
+
+function printDeprecated(reason) {
+  if (reason == null) {
+    return '';
+  }
+
+  if (reason !== _directives.DEFAULT_DEPRECATION_REASON) {
+    const astValue = (0, _printer.print)({
+      kind: _kinds.Kind.STRING,
+      value: reason,
+    });
+    return ` @deprecated(reason: ${astValue})`;
+  }
+
+  return ' @deprecated';
+}
+
+function printSpecifiedByURL(scalar) {
+  if (scalar.specifiedByURL == null) {
+    return '';
+  }
+
+  const astValue = (0, _printer.print)({
+    kind: _kinds.Kind.STRING,
+    value: scalar.specifiedByURL,
+  });
+  return ` @specifiedBy(url: ${astValue})`;
+}
+
+function printDescription(def, indentation = '', firstInBlock = true) {
+  const { description } = def;
+
+  if (description == null) {
+    return '';
+  }
+
+  const blockString = (0, _printer.print)({
+    kind: _kinds.Kind.STRING,
+    value: description,
+    block: (0, _blockString.isPrintableAsBlockString)(description),
+  });
+  const prefix =
+    indentation && !firstInBlock ? '\n' + indentation : indentation;
+  return prefix + blockString.replace(/\n/g, '\n' + indentation) + '\n';
+}