@quantiya/codevibe-claude-plugin 1.0.0 → 1.0.2

package/node_modules/graphql/utilities/resolveSchemaCoordinate.mjs

@@ -0,0 +1,243 @@
+import { inspect } from '../jsutils/inspect.mjs';
+import { Kind } from '../language/kinds.mjs';
+import { parseSchemaCoordinate } from '../language/parser.mjs';
+import {
+  isEnumType,
+  isInputObjectType,
+  isInterfaceType,
+  isObjectType,
+} from '../type/definition.mjs';
+
+/**
+ * A schema coordinate is resolved in the context of a GraphQL schema to
+ * uniquely identify a schema element. It returns undefined if the schema
+ * coordinate does not resolve to a schema element, meta-field, or introspection
+ * schema element. It will throw if the containing schema element (if
+ * applicable) does not exist.
+ *
+ * https://spec.graphql.org/draft/#sec-Schema-Coordinates.Semantics
+ */
+export function resolveSchemaCoordinate(schema, schemaCoordinate) {
+  return resolveASTSchemaCoordinate(
+    schema,
+    parseSchemaCoordinate(schemaCoordinate),
+  );
+}
+/**
+ * TypeCoordinate : Name
+ */
+
+function resolveTypeCoordinate(schema, schemaCoordinate) {
+  // 1. Let {typeName} be the value of {Name}.
+  const typeName = schemaCoordinate.name.value;
+  const type = schema.getType(typeName); // 2. Return the type in the {schema} named {typeName} if it exists.
+
+  if (type == null) {
+    return;
+  }
+
+  return {
+    kind: 'NamedType',
+    type,
+  };
+}
+/**
+ * MemberCoordinate : Name . Name
+ */
+
+function resolveMemberCoordinate(schema, schemaCoordinate) {
+  // 1. Let {typeName} be the value of the first {Name}.
+  // 2. Let {type} be the type in the {schema} named {typeName}.
+  const typeName = schemaCoordinate.name.value;
+  const type = schema.getType(typeName); // 3. Assert: {type} must exist, and must be an Enum, Input Object, Object or Interface type.
+
+  if (!type) {
+    throw new Error(
+      `Expected ${inspect(typeName)} to be defined as a type in the schema.`,
+    );
+  }
+
+  if (
+    !isEnumType(type) &&
+    !isInputObjectType(type) &&
+    !isObjectType(type) &&
+    !isInterfaceType(type)
+  ) {
+    throw new Error(
+      `Expected ${inspect(
+        typeName,
+      )} to be an Enum, Input Object, Object or Interface type.`,
+    );
+  } // 4. If {type} is an Enum type:
+
+  if (isEnumType(type)) {
+    // 1. Let {enumValueName} be the value of the second {Name}.
+    const enumValueName = schemaCoordinate.memberName.value;
+    const enumValue = type.getValue(enumValueName); // 2. Return the enum value of {type} named {enumValueName} if it exists.
+
+    if (enumValue == null) {
+      return;
+    }
+
+    return {
+      kind: 'EnumValue',
+      type,
+      enumValue,
+    };
+  } // 5. Otherwise, if {type} is an Input Object type:
+
+  if (isInputObjectType(type)) {
+    // 1. Let {inputFieldName} be the value of the second {Name}.
+    const inputFieldName = schemaCoordinate.memberName.value;
+    const inputField = type.getFields()[inputFieldName]; // 2. Return the input field of {type} named {inputFieldName} if it exists.
+
+    if (inputField == null) {
+      return;
+    }
+
+    return {
+      kind: 'InputField',
+      type,
+      inputField,
+    };
+  } // 6. Otherwise:
+  // 1. Let {fieldName} be the value of the second {Name}.
+
+  const fieldName = schemaCoordinate.memberName.value;
+  const field = type.getFields()[fieldName]; // 2. Return the field of {type} named {fieldName} if it exists.
+
+  if (field == null) {
+    return;
+  }
+
+  return {
+    kind: 'Field',
+    type,
+    field,
+  };
+}
+/**
+ * ArgumentCoordinate : Name . Name ( Name : )
+ */
+
+function resolveArgumentCoordinate(schema, schemaCoordinate) {
+  // 1. Let {typeName} be the value of the first {Name}.
+  // 2. Let {type} be the type in the {schema} named {typeName}.
+  const typeName = schemaCoordinate.name.value;
+  const type = schema.getType(typeName); // 3. Assert: {type} must exist, and be an Object or Interface type.
+
+  if (type == null) {
+    throw new Error(
+      `Expected ${inspect(typeName)} to be defined as a type in the schema.`,
+    );
+  }
+
+  if (!isObjectType(type) && !isInterfaceType(type)) {
+    throw new Error(
+      `Expected ${inspect(typeName)} to be an object type or interface type.`,
+    );
+  } // 4. Let {fieldName} be the value of the second {Name}.
+  // 5. Let {field} be the field of {type} named {fieldName}.
+
+  const fieldName = schemaCoordinate.fieldName.value;
+  const field = type.getFields()[fieldName]; // 7. Assert: {field} must exist.
+
+  if (field == null) {
+    throw new Error(
+      `Expected ${inspect(fieldName)} to exist as a field of type ${inspect(
+        typeName,
+      )} in the schema.`,
+    );
+  } // 7. Let {fieldArgumentName} be the value of the third {Name}.
+
+  const fieldArgumentName = schemaCoordinate.argumentName.value;
+  const fieldArgument = field.args.find(
+    (arg) => arg.name === fieldArgumentName,
+  ); // 8. Return the argument of {field} named {fieldArgumentName} if it exists.
+
+  if (fieldArgument == null) {
+    return;
+  }
+
+  return {
+    kind: 'FieldArgument',
+    type,
+    field,
+    fieldArgument,
+  };
+}
+/**
+ * DirectiveCoordinate : \@ Name
+ */
+
+function resolveDirectiveCoordinate(schema, schemaCoordinate) {
+  // 1. Let {directiveName} be the value of {Name}.
+  const directiveName = schemaCoordinate.name.value;
+  const directive = schema.getDirective(directiveName); // 2. Return the directive in the {schema} named {directiveName} if it exists.
+
+  if (!directive) {
+    return;
+  }
+
+  return {
+    kind: 'Directive',
+    directive,
+  };
+}
+/**
+ * DirectiveArgumentCoordinate : \@ Name ( Name : )
+ */
+
+function resolveDirectiveArgumentCoordinate(schema, schemaCoordinate) {
+  // 1. Let {directiveName} be the value of the first {Name}.
+  // 2. Let {directive} be the directive in the {schema} named {directiveName}.
+  const directiveName = schemaCoordinate.name.value;
+  const directive = schema.getDirective(directiveName); // 3. Assert {directive} must exist.
+
+  if (!directive) {
+    throw new Error(
+      `Expected ${inspect(
+        directiveName,
+      )} to be defined as a directive in the schema.`,
+    );
+  } // 4. Let {directiveArgumentName} be the value of the second {Name}.
+
+  const {
+    argumentName: { value: directiveArgumentName },
+  } = schemaCoordinate;
+  const directiveArgument = directive.args.find(
+    (arg) => arg.name === directiveArgumentName,
+  ); // 5. Return the argument of {directive} named {directiveArgumentName} if it exists.
+
+  if (!directiveArgument) {
+    return;
+  }
+
+  return {
+    kind: 'DirectiveArgument',
+    directive,
+    directiveArgument,
+  };
+}
+/**
+ * Resolves schema coordinate from a parsed SchemaCoordinate node.
+ */
+
+export function resolveASTSchemaCoordinate(schema, schemaCoordinate) {
+  switch (schemaCoordinate.kind) {
+    case Kind.TYPE_COORDINATE:
+      return resolveTypeCoordinate(schema, schemaCoordinate);
+
+    case Kind.MEMBER_COORDINATE:
+      return resolveMemberCoordinate(schema, schemaCoordinate);
+
+    case Kind.ARGUMENT_COORDINATE:
+      return resolveArgumentCoordinate(schema, schemaCoordinate);
+
+    case Kind.DIRECTIVE_COORDINATE:
+      return resolveDirectiveCoordinate(schema, schemaCoordinate);
+
+    case Kind.DIRECTIVE_ARGUMENT_COORDINATE:
+      return resolveDirectiveArgumentCoordinate(schema, schemaCoordinate);
+  }
+}

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

@@ -0,0 +1,11 @@
+import type { ObjMap } from '../jsutils/ObjMap';
+import type { DocumentNode } from '../language/ast';
+/**
+ * separateOperations accepts a single AST document which may contain many
+ * operations and fragments and returns a collection of AST documents each of
+ * which contains a single operation as well the fragment definitions it
+ * refers to.
+ */
+export declare function separateOperations(
+  documentAST: DocumentNode,
+): ObjMap<DocumentNode>;

package/node_modules/graphql/utilities/separateOperations.js

@@ -0,0 +1,88 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.separateOperations = separateOperations;
+
+var _kinds = require('../language/kinds.js');
+
+var _visitor = require('../language/visitor.js');
+
+/**
+ * separateOperations accepts a single AST document which may contain many
+ * operations and fragments and returns a collection of AST documents each of
+ * which contains a single operation as well the fragment definitions it
+ * refers to.
+ */
+function separateOperations(documentAST) {
+  const operations = [];
+  const depGraph = Object.create(null); // Populate metadata and build a dependency graph.
+
+  for (const definitionNode of documentAST.definitions) {
+    switch (definitionNode.kind) {
+      case _kinds.Kind.OPERATION_DEFINITION:
+        operations.push(definitionNode);
+        break;
+
+      case _kinds.Kind.FRAGMENT_DEFINITION:
+        depGraph[definitionNode.name.value] = collectDependencies(
+          definitionNode.selectionSet,
+        );
+        break;
+
+      default: // ignore non-executable definitions
+    }
+  } // For each operation, produce a new synthesized AST which includes only what
+  // is necessary for completing that operation.
+
+  const separatedDocumentASTs = Object.create(null);
+
+  for (const operation of operations) {
+    const dependencies = new Set();
+
+    for (const fragmentName of collectDependencies(operation.selectionSet)) {
+      collectTransitiveDependencies(dependencies, depGraph, fragmentName);
+    } // Provides the empty string for anonymous operations.
+
+    const operationName = operation.name ? operation.name.value : ''; // The list of definition nodes to be included for this operation, sorted
+    // to retain the same order as the original document.
+
+    separatedDocumentASTs[operationName] = {
+      kind: _kinds.Kind.DOCUMENT,
+      definitions: documentAST.definitions.filter(
+        (node) =>
+          node === operation ||
+          (node.kind === _kinds.Kind.FRAGMENT_DEFINITION &&
+            dependencies.has(node.name.value)),
+      ),
+    };
+  }
+
+  return separatedDocumentASTs;
+}
+
+// From a dependency graph, collects a list of transitive dependencies by
+// recursing through a dependency graph.
+function collectTransitiveDependencies(collected, depGraph, fromName) {
+  if (!collected.has(fromName)) {
+    collected.add(fromName);
+    const immediateDeps = depGraph[fromName];
+
+    if (immediateDeps !== undefined) {
+      for (const toName of immediateDeps) {
+        collectTransitiveDependencies(collected, depGraph, toName);
+      }
+    }
+  }
+}
+
+function collectDependencies(selectionSet) {
+  const dependencies = [];
+  (0, _visitor.visit)(selectionSet, {
+    FragmentSpread(node) {
+      dependencies.push(node.name.value);
+    },
+  });
+  return dependencies;
+}

package/node_modules/graphql/utilities/separateOperations.mjs

@@ -0,0 +1,80 @@
+import { Kind } from '../language/kinds.mjs';
+import { visit } from '../language/visitor.mjs';
+/**
+ * separateOperations accepts a single AST document which may contain many
+ * operations and fragments and returns a collection of AST documents each of
+ * which contains a single operation as well the fragment definitions it
+ * refers to.
+ */
+
+export function separateOperations(documentAST) {
+  const operations = [];
+  const depGraph = Object.create(null); // Populate metadata and build a dependency graph.
+
+  for (const definitionNode of documentAST.definitions) {
+    switch (definitionNode.kind) {
+      case Kind.OPERATION_DEFINITION:
+        operations.push(definitionNode);
+        break;
+
+      case Kind.FRAGMENT_DEFINITION:
+        depGraph[definitionNode.name.value] = collectDependencies(
+          definitionNode.selectionSet,
+        );
+        break;
+
+      default: // ignore non-executable definitions
+    }
+  } // For each operation, produce a new synthesized AST which includes only what
+  // is necessary for completing that operation.
+
+  const separatedDocumentASTs = Object.create(null);
+
+  for (const operation of operations) {
+    const dependencies = new Set();
+
+    for (const fragmentName of collectDependencies(operation.selectionSet)) {
+      collectTransitiveDependencies(dependencies, depGraph, fragmentName);
+    } // Provides the empty string for anonymous operations.
+
+    const operationName = operation.name ? operation.name.value : ''; // The list of definition nodes to be included for this operation, sorted
+    // to retain the same order as the original document.
+
+    separatedDocumentASTs[operationName] = {
+      kind: Kind.DOCUMENT,
+      definitions: documentAST.definitions.filter(
+        (node) =>
+          node === operation ||
+          (node.kind === Kind.FRAGMENT_DEFINITION &&
+            dependencies.has(node.name.value)),
+      ),
+    };
+  }
+
+  return separatedDocumentASTs;
+}
+
+// From a dependency graph, collects a list of transitive dependencies by
+// recursing through a dependency graph.
+function collectTransitiveDependencies(collected, depGraph, fromName) {
+  if (!collected.has(fromName)) {
+    collected.add(fromName);
+    const immediateDeps = depGraph[fromName];
+
+    if (immediateDeps !== undefined) {
+      for (const toName of immediateDeps) {
+        collectTransitiveDependencies(collected, depGraph, toName);
+      }
+    }
+  }
+}
+
+function collectDependencies(selectionSet) {
+  const dependencies = [];
+  visit(selectionSet, {
+    FragmentSpread(node) {
+      dependencies.push(node.name.value);
+    },
+  });
+  return dependencies;
+}

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

@@ -0,0 +1,9 @@
+import type { ValueNode } from '../language/ast';
+/**
+ * Sort ValueNode.
+ *
+ * This function returns a sorted copy of the given ValueNode.
+ *
+ * @internal
+ */
+export declare function sortValueNode(valueNode: ValueNode): ValueNode;

package/node_modules/graphql/utilities/sortValueNode.js

@@ -0,0 +1,47 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.sortValueNode = sortValueNode;
+
+var _naturalCompare = require('../jsutils/naturalCompare.js');
+
+var _kinds = require('../language/kinds.js');
+
+/**
+ * Sort ValueNode.
+ *
+ * This function returns a sorted copy of the given ValueNode.
+ *
+ * @internal
+ */
+function sortValueNode(valueNode) {
+  switch (valueNode.kind) {
+    case _kinds.Kind.OBJECT:
+      return { ...valueNode, fields: sortFields(valueNode.fields) };
+
+    case _kinds.Kind.LIST:
+      return { ...valueNode, values: valueNode.values.map(sortValueNode) };
+
+    case _kinds.Kind.INT:
+    case _kinds.Kind.FLOAT:
+    case _kinds.Kind.STRING:
+    case _kinds.Kind.BOOLEAN:
+    case _kinds.Kind.NULL:
+    case _kinds.Kind.ENUM:
+    case _kinds.Kind.VARIABLE:
+      return valueNode;
+  }
+}
+
+function sortFields(fields) {
+  return fields
+    .map((fieldNode) => ({
+      ...fieldNode,
+      value: sortValueNode(fieldNode.value),
+    }))
+    .sort((fieldA, fieldB) =>
+      (0, _naturalCompare.naturalCompare)(fieldA.name.value, fieldB.name.value),
+    );
+}

package/node_modules/graphql/utilities/sortValueNode.mjs

@@ -0,0 +1,39 @@
+import { naturalCompare } from '../jsutils/naturalCompare.mjs';
+import { Kind } from '../language/kinds.mjs';
+/**
+ * Sort ValueNode.
+ *
+ * This function returns a sorted copy of the given ValueNode.
+ *
+ * @internal
+ */
+
+export function sortValueNode(valueNode) {
+  switch (valueNode.kind) {
+    case Kind.OBJECT:
+      return { ...valueNode, fields: sortFields(valueNode.fields) };
+
+    case Kind.LIST:
+      return { ...valueNode, values: valueNode.values.map(sortValueNode) };
+
+    case Kind.INT:
+    case Kind.FLOAT:
+    case Kind.STRING:
+    case Kind.BOOLEAN:
+    case Kind.NULL:
+    case Kind.ENUM:
+    case Kind.VARIABLE:
+      return valueNode;
+  }
+}
+
+function sortFields(fields) {
+  return fields
+    .map((fieldNode) => ({
+      ...fieldNode,
+      value: sortValueNode(fieldNode.value),
+    }))
+    .sort((fieldA, fieldB) =>
+      naturalCompare(fieldA.name.value, fieldB.name.value),
+    );
+}

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

@@ -0,0 +1,62 @@
+import { Source } from '../language/source';
+/**
+ * Strips characters that are not significant to the validity or execution
+ * of a GraphQL document:
+ *   - UnicodeBOM
+ *   - WhiteSpace
+ *   - LineTerminator
+ *   - Comment
+ *   - Comma
+ *   - BlockString indentation
+ *
+ * Note: It is required to have a delimiter character between neighboring
+ * non-punctuator tokens and this function always uses single space as delimiter.
+ *
+ * It is guaranteed that both input and output documents if parsed would result
+ * in the exact same AST except for nodes location.
+ *
+ * Warning: It is guaranteed that this function will always produce stable results.
+ * However, it's not guaranteed that it will stay the same between different
+ * releases due to bugfixes or changes in the GraphQL specification.
+ *
+ * Query example:
+ *
+ * ```graphql
+ * query SomeQuery($foo: String!, $bar: String) {
+ *   someField(foo: $foo, bar: $bar) {
+ *     a
+ *     b {
+ *       c
+ *       d
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * Becomes:
+ *
+ * ```graphql
+ * query SomeQuery($foo:String!$bar:String){someField(foo:$foo bar:$bar){a b{c d}}}
+ * ```
+ *
+ * SDL example:
+ *
+ * ```graphql
+ * """
+ * Type description
+ * """
+ * type Foo {
+ *   """
+ *   Field description
+ *   """
+ *   bar: String
+ * }
+ * ```
+ *
+ * Becomes:
+ *
+ * ```graphql
+ * """Type description""" type Foo{"""Field description""" bar:String}
+ * ```
+ */
+export declare function stripIgnoredCharacters(source: string | Source): string;

package/node_modules/graphql/utilities/stripIgnoredCharacters.js

@@ -0,0 +1,121 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.stripIgnoredCharacters = stripIgnoredCharacters;
+
+var _blockString = require('../language/blockString.js');
+
+var _lexer = require('../language/lexer.js');
+
+var _source = require('../language/source.js');
+
+var _tokenKind = require('../language/tokenKind.js');
+
+/**
+ * Strips characters that are not significant to the validity or execution
+ * of a GraphQL document:
+ *   - UnicodeBOM
+ *   - WhiteSpace
+ *   - LineTerminator
+ *   - Comment
+ *   - Comma
+ *   - BlockString indentation
+ *
+ * Note: It is required to have a delimiter character between neighboring
+ * non-punctuator tokens and this function always uses single space as delimiter.
+ *
+ * It is guaranteed that both input and output documents if parsed would result
+ * in the exact same AST except for nodes location.
+ *
+ * Warning: It is guaranteed that this function will always produce stable results.
+ * However, it's not guaranteed that it will stay the same between different
+ * releases due to bugfixes or changes in the GraphQL specification.
+ *
+ * Query example:
+ *
+ * ```graphql
+ * query SomeQuery($foo: String!, $bar: String) {
+ *   someField(foo: $foo, bar: $bar) {
+ *     a
+ *     b {
+ *       c
+ *       d
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * Becomes:
+ *
+ * ```graphql
+ * query SomeQuery($foo:String!$bar:String){someField(foo:$foo bar:$bar){a b{c d}}}
+ * ```
+ *
+ * SDL example:
+ *
+ * ```graphql
+ * """
+ * Type description
+ * """
+ * type Foo {
+ *   """
+ *   Field description
+ *   """
+ *   bar: String
+ * }
+ * ```
+ *
+ * Becomes:
+ *
+ * ```graphql
+ * """Type description""" type Foo{"""Field description""" bar:String}
+ * ```
+ */
+function stripIgnoredCharacters(source) {
+  const sourceObj = (0, _source.isSource)(source)
+    ? source
+    : new _source.Source(source);
+  const body = sourceObj.body;
+  const lexer = new _lexer.Lexer(sourceObj);
+  let strippedBody = '';
+  let wasLastAddedTokenNonPunctuator = false;
+
+  while (lexer.advance().kind !== _tokenKind.TokenKind.EOF) {
+    const currentToken = lexer.token;
+    const tokenKind = currentToken.kind;
+    /**
+     * Every two non-punctuator tokens should have space between them.
+     * Also prevent case of non-punctuator token following by spread resulting
+     * in invalid token (e.g. `1...` is invalid Float token).
+     */
+
+    const isNonPunctuator = !(0, _lexer.isPunctuatorTokenKind)(
+      currentToken.kind,
+    );
+
+    if (wasLastAddedTokenNonPunctuator) {
+      if (
+        isNonPunctuator ||
+        currentToken.kind === _tokenKind.TokenKind.SPREAD
+      ) {
+        strippedBody += ' ';
+      }
+    }
+
+    const tokenBody = body.slice(currentToken.start, currentToken.end);
+
+    if (tokenKind === _tokenKind.TokenKind.BLOCK_STRING) {
+      strippedBody += (0, _blockString.printBlockString)(currentToken.value, {
+        minimize: true,
+      });
+    } else {
+      strippedBody += tokenBody;
+    }
+
+    wasLastAddedTokenNonPunctuator = isNonPunctuator;
+  }
+
+  return strippedBody;
+}