@pome-sh/cli 0.3.0 → 0.4.0

package/node_modules/graphql/validation/rules/UniqueDirectiveNamesRule.d.ts

@@ -0,0 +1,31 @@
+/** @category Validation Rules */
+import type { ASTVisitor } from '../../language/visitor';
+import type { SDLValidationContext } from '../ValidationContext';
+/**
+ * Unique directive names
+ *
+ * A GraphQL document is only valid if all defined directives have unique names.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql';
+ * import { UniqueDirectiveNamesRule } from 'graphql/validation';
+ *
+ * const invalidSDL = `
+ *   directive @tag on FIELD directive @tag on QUERY type Query { name: String }
+ * `;
+ *
+ * UniqueDirectiveNamesRule.name; // => 'UniqueDirectiveNamesRule'
+ * buildSchema(invalidSDL); // throws an error
+ *
+ * const validSDL = `
+ *   directive @tag on FIELD type Query { name: String }
+ * `;
+ *
+ * buildSchema(validSDL); // does not throw
+ * ```
+ */
+export declare function UniqueDirectiveNamesRule(
+  context: SDLValidationContext,
+): ASTVisitor;

package/node_modules/graphql/validation/rules/UniqueDirectiveNamesRule.js

@@ -0,0 +1,76 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.UniqueDirectiveNamesRule = UniqueDirectiveNamesRule;
+
+var _GraphQLError = require('../../error/GraphQLError.js');
+
+/** @category Validation Rules */
+
+/**
+ * Unique directive names
+ *
+ * A GraphQL document is only valid if all defined directives have unique names.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql';
+ * import { UniqueDirectiveNamesRule } from 'graphql/validation';
+ *
+ * const invalidSDL = `
+ *   directive @tag on FIELD directive @tag on QUERY type Query { name: String }
+ * `;
+ *
+ * UniqueDirectiveNamesRule.name; // => 'UniqueDirectiveNamesRule'
+ * buildSchema(invalidSDL); // throws an error
+ *
+ * const validSDL = `
+ *   directive @tag on FIELD type Query { name: String }
+ * `;
+ *
+ * buildSchema(validSDL); // does not throw
+ * ```
+ */
+function UniqueDirectiveNamesRule(context) {
+  const knownDirectiveNames = Object.create(null);
+  const schema = context.getSchema();
+  return {
+    DirectiveDefinition(node) {
+      const directiveName = node.name.value;
+
+      if (
+        schema !== null &&
+        schema !== void 0 &&
+        schema.getDirective(directiveName)
+      ) {
+        context.reportError(
+          new _GraphQLError.GraphQLError(
+            `Directive "@${directiveName}" already exists in the schema. It cannot be redefined.`,
+            {
+              nodes: node.name,
+            },
+          ),
+        );
+        return;
+      }
+
+      if (knownDirectiveNames[directiveName]) {
+        context.reportError(
+          new _GraphQLError.GraphQLError(
+            `There can be only one directive named "@${directiveName}".`,
+            {
+              nodes: [knownDirectiveNames[directiveName], node.name],
+            },
+          ),
+        );
+      } else {
+        knownDirectiveNames[directiveName] = node.name;
+      }
+
+      return false;
+    },
+  };
+}

package/node_modules/graphql/validation/rules/UniqueDirectiveNamesRule.mjs

@@ -0,0 +1,68 @@
+/** @category Validation Rules */
+import { GraphQLError } from '../../error/GraphQLError.mjs';
+
+/**
+ * Unique directive names
+ *
+ * A GraphQL document is only valid if all defined directives have unique names.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql';
+ * import { UniqueDirectiveNamesRule } from 'graphql/validation';
+ *
+ * const invalidSDL = `
+ *   directive @tag on FIELD directive @tag on QUERY type Query { name: String }
+ * `;
+ *
+ * UniqueDirectiveNamesRule.name; // => 'UniqueDirectiveNamesRule'
+ * buildSchema(invalidSDL); // throws an error
+ *
+ * const validSDL = `
+ *   directive @tag on FIELD type Query { name: String }
+ * `;
+ *
+ * buildSchema(validSDL); // does not throw
+ * ```
+ */
+export function UniqueDirectiveNamesRule(context) {
+  const knownDirectiveNames = Object.create(null);
+  const schema = context.getSchema();
+  return {
+    DirectiveDefinition(node) {
+      const directiveName = node.name.value;
+
+      if (
+        schema !== null &&
+        schema !== void 0 &&
+        schema.getDirective(directiveName)
+      ) {
+        context.reportError(
+          new GraphQLError(
+            `Directive "@${directiveName}" already exists in the schema. It cannot be redefined.`,
+            {
+              nodes: node.name,
+            },
+          ),
+        );
+        return;
+      }
+
+      if (knownDirectiveNames[directiveName]) {
+        context.reportError(
+          new GraphQLError(
+            `There can be only one directive named "@${directiveName}".`,
+            {
+              nodes: [knownDirectiveNames[directiveName], node.name],
+            },
+          ),
+        );
+      } else {
+        knownDirectiveNames[directiveName] = node.name;
+      }
+
+      return false;
+    },
+  };
+}

package/node_modules/graphql/validation/rules/UniqueDirectivesPerLocationRule.d.ts

@@ -0,0 +1,44 @@
+/** @category Validation Rules */
+import type { ASTVisitor } from '../../language/visitor';
+import type {
+  SDLValidationContext,
+  ValidationContext,
+} from '../ValidationContext';
+/**
+ * Unique directive names per location
+ *
+ * A GraphQL document is only valid if all non-repeatable directives at
+ * a given location are uniquely named.
+ *
+ * See https://spec.graphql.org/draft/#sec-Directives-Are-Unique-Per-Location
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { UniqueDirectivesPerLocationRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { name @include(if: true) @include(if: false) }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [UniqueDirectivesPerLocationRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { name @include(if: true) }
+ * `);
+ * const validErrors = validate(schema, validDocument, [UniqueDirectivesPerLocationRule]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+export declare function UniqueDirectivesPerLocationRule(
+  context: ValidationContext | SDLValidationContext,
+): ASTVisitor;

package/node_modules/graphql/validation/rules/UniqueDirectivesPerLocationRule.js

@@ -0,0 +1,136 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.UniqueDirectivesPerLocationRule = UniqueDirectivesPerLocationRule;
+
+var _GraphQLError = require('../../error/GraphQLError.js');
+
+var _kinds = require('../../language/kinds.js');
+
+var _predicates = require('../../language/predicates.js');
+
+var _directives = require('../../type/directives.js');
+
+/** @category Validation Rules */
+
+/**
+ * Unique directive names per location
+ *
+ * A GraphQL document is only valid if all non-repeatable directives at
+ * a given location are uniquely named.
+ *
+ * See https://spec.graphql.org/draft/#sec-Directives-Are-Unique-Per-Location
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { UniqueDirectivesPerLocationRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { name @include(if: true) @include(if: false) }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [UniqueDirectivesPerLocationRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { name @include(if: true) }
+ * `);
+ * const validErrors = validate(schema, validDocument, [UniqueDirectivesPerLocationRule]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+function UniqueDirectivesPerLocationRule(context) {
+  const uniqueDirectiveMap = Object.create(null);
+  const schema = context.getSchema();
+  const definedDirectives = schema
+    ? schema.getDirectives()
+    : _directives.specifiedDirectives;
+
+  for (const directive of definedDirectives) {
+    uniqueDirectiveMap[directive.name] = !directive.isRepeatable;
+  }
+
+  const astDefinitions = context.getDocument().definitions;
+
+  for (const def of astDefinitions) {
+    if (def.kind === _kinds.Kind.DIRECTIVE_DEFINITION) {
+      uniqueDirectiveMap[def.name.value] = !def.repeatable;
+    }
+  }
+
+  const schemaDirectives = Object.create(null);
+  const typeDirectivesMap = Object.create(null);
+  const directiveDirectivesMap = Object.create(null);
+  return {
+    // Many different AST nodes may contain directives. Rather than listing
+    // them all, just listen for entering any node, and check to see if it
+    // defines any directives.
+    enter(node) {
+      if (!('directives' in node) || !node.directives) {
+        return;
+      }
+
+      let seenDirectives;
+
+      if (
+        node.kind === _kinds.Kind.SCHEMA_DEFINITION ||
+        node.kind === _kinds.Kind.SCHEMA_EXTENSION
+      ) {
+        seenDirectives = schemaDirectives;
+      } else if (
+        (0, _predicates.isTypeDefinitionNode)(node) ||
+        (0, _predicates.isTypeExtensionNode)(node)
+      ) {
+        const typeName = node.name.value;
+        seenDirectives = typeDirectivesMap[typeName];
+
+        if (seenDirectives === undefined) {
+          typeDirectivesMap[typeName] = seenDirectives = Object.create(null);
+        }
+      } else if (
+        node.kind === _kinds.Kind.DIRECTIVE_DEFINITION ||
+        node.kind === _kinds.Kind.DIRECTIVE_EXTENSION
+      ) {
+        const directiveName = node.name.value;
+        seenDirectives = directiveDirectivesMap[directiveName];
+
+        if (seenDirectives === undefined) {
+          directiveDirectivesMap[directiveName] = seenDirectives =
+            Object.create(null);
+        }
+      } else {
+        seenDirectives = Object.create(null);
+      }
+
+      for (const directive of node.directives) {
+        const directiveName = directive.name.value;
+
+        if (uniqueDirectiveMap[directiveName]) {
+          if (seenDirectives[directiveName]) {
+            context.reportError(
+              new _GraphQLError.GraphQLError(
+                `The directive "@${directiveName}" can only be used once at this location.`,
+                {
+                  nodes: [seenDirectives[directiveName], directive],
+                },
+              ),
+            );
+          } else {
+            seenDirectives[directiveName] = directive;
+          }
+        }
+      }
+    },
+  };
+}

package/node_modules/graphql/validation/rules/UniqueDirectivesPerLocationRule.mjs

@@ -0,0 +1,125 @@
+/** @category Validation Rules */
+import { GraphQLError } from '../../error/GraphQLError.mjs';
+import { Kind } from '../../language/kinds.mjs';
+import {
+  isTypeDefinitionNode,
+  isTypeExtensionNode,
+} from '../../language/predicates.mjs';
+import { specifiedDirectives } from '../../type/directives.mjs';
+
+/**
+ * Unique directive names per location
+ *
+ * A GraphQL document is only valid if all non-repeatable directives at
+ * a given location are uniquely named.
+ *
+ * See https://spec.graphql.org/draft/#sec-Directives-Are-Unique-Per-Location
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema, parse, validate } from 'graphql';
+ * import { UniqueDirectivesPerLocationRule } from 'graphql/validation';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     name: String
+ *   }
+ * `);
+ *
+ * const invalidDocument = parse(`
+ *   { name @include(if: true) @include(if: false) }
+ * `);
+ * const invalidErrors = validate(schema, invalidDocument, [UniqueDirectivesPerLocationRule]);
+ *
+ * invalidErrors.length; // => 1
+ *
+ * const validDocument = parse(`
+ *   { name @include(if: true) }
+ * `);
+ * const validErrors = validate(schema, validDocument, [UniqueDirectivesPerLocationRule]);
+ *
+ * validErrors; // => []
+ * ```
+ */
+export function UniqueDirectivesPerLocationRule(context) {
+  const uniqueDirectiveMap = Object.create(null);
+  const schema = context.getSchema();
+  const definedDirectives = schema
+    ? schema.getDirectives()
+    : specifiedDirectives;
+
+  for (const directive of definedDirectives) {
+    uniqueDirectiveMap[directive.name] = !directive.isRepeatable;
+  }
+
+  const astDefinitions = context.getDocument().definitions;
+
+  for (const def of astDefinitions) {
+    if (def.kind === Kind.DIRECTIVE_DEFINITION) {
+      uniqueDirectiveMap[def.name.value] = !def.repeatable;
+    }
+  }
+
+  const schemaDirectives = Object.create(null);
+  const typeDirectivesMap = Object.create(null);
+  const directiveDirectivesMap = Object.create(null);
+  return {
+    // Many different AST nodes may contain directives. Rather than listing
+    // them all, just listen for entering any node, and check to see if it
+    // defines any directives.
+    enter(node) {
+      if (!('directives' in node) || !node.directives) {
+        return;
+      }
+
+      let seenDirectives;
+
+      if (
+        node.kind === Kind.SCHEMA_DEFINITION ||
+        node.kind === Kind.SCHEMA_EXTENSION
+      ) {
+        seenDirectives = schemaDirectives;
+      } else if (isTypeDefinitionNode(node) || isTypeExtensionNode(node)) {
+        const typeName = node.name.value;
+        seenDirectives = typeDirectivesMap[typeName];
+
+        if (seenDirectives === undefined) {
+          typeDirectivesMap[typeName] = seenDirectives = Object.create(null);
+        }
+      } else if (
+        node.kind === Kind.DIRECTIVE_DEFINITION ||
+        node.kind === Kind.DIRECTIVE_EXTENSION
+      ) {
+        const directiveName = node.name.value;
+        seenDirectives = directiveDirectivesMap[directiveName];
+
+        if (seenDirectives === undefined) {
+          directiveDirectivesMap[directiveName] = seenDirectives =
+            Object.create(null);
+        }
+      } else {
+        seenDirectives = Object.create(null);
+      }
+
+      for (const directive of node.directives) {
+        const directiveName = directive.name.value;
+
+        if (uniqueDirectiveMap[directiveName]) {
+          if (seenDirectives[directiveName]) {
+            context.reportError(
+              new GraphQLError(
+                `The directive "@${directiveName}" can only be used once at this location.`,
+                {
+                  nodes: [seenDirectives[directiveName], directive],
+                },
+              ),
+            );
+          } else {
+            seenDirectives[directiveName] = directive;
+          }
+        }
+      }
+    },
+  };
+}

package/node_modules/graphql/validation/rules/UniqueEnumValueNamesRule.d.ts

@@ -0,0 +1,31 @@
+/** @category Validation Rules */
+import type { ASTVisitor } from '../../language/visitor';
+import type { SDLValidationContext } from '../ValidationContext';
+/**
+ * Unique enum value names
+ *
+ * A GraphQL enum type is only valid if all its values are uniquely named.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql';
+ * import { UniqueEnumValueNamesRule } from 'graphql/validation';
+ *
+ * const invalidSDL = `
+ *   enum Status { ACTIVE ACTIVE } type Query { status: Status }
+ * `;
+ *
+ * UniqueEnumValueNamesRule.name; // => 'UniqueEnumValueNamesRule'
+ * buildSchema(invalidSDL); // throws an error
+ *
+ * const validSDL = `
+ *   enum Status { ACTIVE INACTIVE } type Query { status: Status }
+ * `;
+ *
+ * buildSchema(validSDL); // does not throw
+ * ```
+ */
+export declare function UniqueEnumValueNamesRule(
+  context: SDLValidationContext,
+): ASTVisitor;

package/node_modules/graphql/validation/rules/UniqueEnumValueNamesRule.js

@@ -0,0 +1,97 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.UniqueEnumValueNamesRule = UniqueEnumValueNamesRule;
+
+var _GraphQLError = require('../../error/GraphQLError.js');
+
+var _definition = require('../../type/definition.js');
+
+/** @category Validation Rules */
+
+/**
+ * Unique enum value names
+ *
+ * A GraphQL enum type is only valid if all its values are uniquely named.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql';
+ * import { UniqueEnumValueNamesRule } from 'graphql/validation';
+ *
+ * const invalidSDL = `
+ *   enum Status { ACTIVE ACTIVE } type Query { status: Status }
+ * `;
+ *
+ * UniqueEnumValueNamesRule.name; // => 'UniqueEnumValueNamesRule'
+ * buildSchema(invalidSDL); // throws an error
+ *
+ * const validSDL = `
+ *   enum Status { ACTIVE INACTIVE } type Query { status: Status }
+ * `;
+ *
+ * buildSchema(validSDL); // does not throw
+ * ```
+ */
+function UniqueEnumValueNamesRule(context) {
+  const schema = context.getSchema();
+  const existingTypeMap = schema ? schema.getTypeMap() : Object.create(null);
+  const knownValueNames = Object.create(null);
+  return {
+    EnumTypeDefinition: checkValueUniqueness,
+    EnumTypeExtension: checkValueUniqueness,
+  };
+
+  function checkValueUniqueness(node) {
+    var _node$values;
+
+    const typeName = node.name.value;
+
+    if (!knownValueNames[typeName]) {
+      knownValueNames[typeName] = Object.create(null);
+    } // FIXME: https://github.com/graphql/graphql-js/issues/2203
+
+    /* c8 ignore next */
+
+    const valueNodes =
+      (_node$values = node.values) !== null && _node$values !== void 0
+        ? _node$values
+        : [];
+    const valueNames = knownValueNames[typeName];
+
+    for (const valueDef of valueNodes) {
+      const valueName = valueDef.name.value;
+      const existingType = existingTypeMap[typeName];
+
+      if (
+        (0, _definition.isEnumType)(existingType) &&
+        existingType.getValue(valueName)
+      ) {
+        context.reportError(
+          new _GraphQLError.GraphQLError(
+            `Enum value "${typeName}.${valueName}" already exists in the schema. It cannot also be defined in this type extension.`,
+            {
+              nodes: valueDef.name,
+            },
+          ),
+        );
+      } else if (valueNames[valueName]) {
+        context.reportError(
+          new _GraphQLError.GraphQLError(
+            `Enum value "${typeName}.${valueName}" can only be defined once.`,
+            {
+              nodes: [valueNames[valueName], valueDef.name],
+            },
+          ),
+        );
+      } else {
+        valueNames[valueName] = valueDef.name;
+      }
+    }
+
+    return false;
+  }
+}

package/node_modules/graphql/validation/rules/UniqueEnumValueNamesRule.mjs

@@ -0,0 +1,85 @@
+/** @category Validation Rules */
+import { GraphQLError } from '../../error/GraphQLError.mjs';
+import { isEnumType } from '../../type/definition.mjs';
+
+/**
+ * Unique enum value names
+ *
+ * A GraphQL enum type is only valid if all its values are uniquely named.
+ * @param context - The validation context used while checking the document.
+ * @returns A visitor that reports validation errors for this rule.
+ * @example
+ * ```ts
+ * import { buildSchema } from 'graphql';
+ * import { UniqueEnumValueNamesRule } from 'graphql/validation';
+ *
+ * const invalidSDL = `
+ *   enum Status { ACTIVE ACTIVE } type Query { status: Status }
+ * `;
+ *
+ * UniqueEnumValueNamesRule.name; // => 'UniqueEnumValueNamesRule'
+ * buildSchema(invalidSDL); // throws an error
+ *
+ * const validSDL = `
+ *   enum Status { ACTIVE INACTIVE } type Query { status: Status }
+ * `;
+ *
+ * buildSchema(validSDL); // does not throw
+ * ```
+ */
+export function UniqueEnumValueNamesRule(context) {
+  const schema = context.getSchema();
+  const existingTypeMap = schema ? schema.getTypeMap() : Object.create(null);
+  const knownValueNames = Object.create(null);
+  return {
+    EnumTypeDefinition: checkValueUniqueness,
+    EnumTypeExtension: checkValueUniqueness,
+  };
+
+  function checkValueUniqueness(node) {
+    var _node$values;
+
+    const typeName = node.name.value;
+
+    if (!knownValueNames[typeName]) {
+      knownValueNames[typeName] = Object.create(null);
+    } // FIXME: https://github.com/graphql/graphql-js/issues/2203
+
+    /* c8 ignore next */
+
+    const valueNodes =
+      (_node$values = node.values) !== null && _node$values !== void 0
+        ? _node$values
+        : [];
+    const valueNames = knownValueNames[typeName];
+
+    for (const valueDef of valueNodes) {
+      const valueName = valueDef.name.value;
+      const existingType = existingTypeMap[typeName];
+
+      if (isEnumType(existingType) && existingType.getValue(valueName)) {
+        context.reportError(
+          new GraphQLError(
+            `Enum value "${typeName}.${valueName}" already exists in the schema. It cannot also be defined in this type extension.`,
+            {
+              nodes: valueDef.name,
+            },
+          ),
+        );
+      } else if (valueNames[valueName]) {
+        context.reportError(
+          new GraphQLError(
+            `Enum value "${typeName}.${valueName}" can only be defined once.`,
+            {
+              nodes: [valueNames[valueName], valueDef.name],
+            },
+          ),
+        );
+      } else {
+        valueNames[valueName] = valueDef.name;
+      }
+    }
+
+    return false;
+  }
+}