@quantiya/codevibe-claude-plugin 1.0.0 → 1.0.1

package/node_modules/graphql/utilities/TypeInfo.mjs

@@ -0,0 +1,395 @@
+import { isNode } from '../language/ast.mjs';
+import { Kind } from '../language/kinds.mjs';
+import { getEnterLeaveForKind } from '../language/visitor.mjs';
+import {
+  getNamedType,
+  getNullableType,
+  isCompositeType,
+  isEnumType,
+  isInputObjectType,
+  isInputType,
+  isInterfaceType,
+  isListType,
+  isObjectType,
+  isOutputType,
+} from '../type/definition.mjs';
+import {
+  SchemaMetaFieldDef,
+  TypeMetaFieldDef,
+  TypeNameMetaFieldDef,
+} from '../type/introspection.mjs';
+import { typeFromAST } from './typeFromAST.mjs';
+/**
+ * TypeInfo is a utility class which, given a GraphQL schema, can keep track
+ * of the current field and type definitions at any point in a GraphQL document
+ * AST during a recursive descent by calling `enter(node)` and `leave(node)`.
+ */
+
+export class TypeInfo {
+  constructor(
+    schema,
+    /**
+     * Initial type may be provided in rare cases to facilitate traversals
+     *  beginning somewhere other than documents.
+     */
+    initialType,
+    /** @deprecated will be removed in 17.0.0 */
+    getFieldDefFn,
+  ) {
+    this._schema = schema;
+    this._typeStack = [];
+    this._parentTypeStack = [];
+    this._inputTypeStack = [];
+    this._fieldDefStack = [];
+    this._defaultValueStack = [];
+    this._directive = null;
+    this._argument = null;
+    this._enumValue = null;
+    this._getFieldDef =
+      getFieldDefFn !== null && getFieldDefFn !== void 0
+        ? getFieldDefFn
+        : getFieldDef;
+
+    if (initialType) {
+      if (isInputType(initialType)) {
+        this._inputTypeStack.push(initialType);
+      }
+
+      if (isCompositeType(initialType)) {
+        this._parentTypeStack.push(initialType);
+      }
+
+      if (isOutputType(initialType)) {
+        this._typeStack.push(initialType);
+      }
+    }
+  }
+
+  get [Symbol.toStringTag]() {
+    return 'TypeInfo';
+  }
+
+  getType() {
+    if (this._typeStack.length > 0) {
+      return this._typeStack[this._typeStack.length - 1];
+    }
+  }
+
+  getParentType() {
+    if (this._parentTypeStack.length > 0) {
+      return this._parentTypeStack[this._parentTypeStack.length - 1];
+    }
+  }
+
+  getInputType() {
+    if (this._inputTypeStack.length > 0) {
+      return this._inputTypeStack[this._inputTypeStack.length - 1];
+    }
+  }
+
+  getParentInputType() {
+    if (this._inputTypeStack.length > 1) {
+      return this._inputTypeStack[this._inputTypeStack.length - 2];
+    }
+  }
+
+  getFieldDef() {
+    if (this._fieldDefStack.length > 0) {
+      return this._fieldDefStack[this._fieldDefStack.length - 1];
+    }
+  }
+
+  getDefaultValue() {
+    if (this._defaultValueStack.length > 0) {
+      return this._defaultValueStack[this._defaultValueStack.length - 1];
+    }
+  }
+
+  getDirective() {
+    return this._directive;
+  }
+
+  getArgument() {
+    return this._argument;
+  }
+
+  getEnumValue() {
+    return this._enumValue;
+  }
+
+  enter(node) {
+    const schema = this._schema; // Note: many of the types below are explicitly typed as "unknown" to drop
+    // any assumptions of a valid schema to ensure runtime types are properly
+    // checked before continuing since TypeInfo is used as part of validation
+    // which occurs before guarantees of schema and document validity.
+
+    switch (node.kind) {
+      case Kind.SELECTION_SET: {
+        const namedType = getNamedType(this.getType());
+
+        this._parentTypeStack.push(
+          isCompositeType(namedType) ? namedType : undefined,
+        );
+
+        break;
+      }
+
+      case Kind.FIELD: {
+        const parentType = this.getParentType();
+        let fieldDef;
+        let fieldType;
+
+        if (parentType) {
+          fieldDef = this._getFieldDef(schema, parentType, node);
+
+          if (fieldDef) {
+            fieldType = fieldDef.type;
+          }
+        }
+
+        this._fieldDefStack.push(fieldDef);
+
+        this._typeStack.push(isOutputType(fieldType) ? fieldType : undefined);
+
+        break;
+      }
+
+      case Kind.DIRECTIVE:
+        this._directive = schema.getDirective(node.name.value);
+        break;
+
+      case Kind.OPERATION_DEFINITION: {
+        const rootType = schema.getRootType(node.operation);
+
+        this._typeStack.push(isObjectType(rootType) ? rootType : undefined);
+
+        break;
+      }
+
+      case Kind.INLINE_FRAGMENT:
+      case Kind.FRAGMENT_DEFINITION: {
+        const typeConditionAST = node.typeCondition;
+        const outputType = typeConditionAST
+          ? typeFromAST(schema, typeConditionAST)
+          : getNamedType(this.getType());
+
+        this._typeStack.push(isOutputType(outputType) ? outputType : undefined);
+
+        break;
+      }
+
+      case Kind.VARIABLE_DEFINITION: {
+        const inputType = typeFromAST(schema, node.type);
+
+        this._inputTypeStack.push(
+          isInputType(inputType) ? inputType : undefined,
+        );
+
+        break;
+      }
+
+      case Kind.ARGUMENT: {
+        var _this$getDirective;
+
+        let argDef;
+        let argType;
+        const fieldOrDirective =
+          (_this$getDirective = this.getDirective()) !== null &&
+          _this$getDirective !== void 0
+            ? _this$getDirective
+            : this.getFieldDef();
+
+        if (fieldOrDirective) {
+          argDef = fieldOrDirective.args.find(
+            (arg) => arg.name === node.name.value,
+          );
+
+          if (argDef) {
+            argType = argDef.type;
+          }
+        }
+
+        this._argument = argDef;
+
+        this._defaultValueStack.push(argDef ? argDef.defaultValue : undefined);
+
+        this._inputTypeStack.push(isInputType(argType) ? argType : undefined);
+
+        break;
+      }
+
+      case Kind.LIST: {
+        const listType = getNullableType(this.getInputType());
+        const itemType = isListType(listType) ? listType.ofType : listType; // List positions never have a default value.
+
+        this._defaultValueStack.push(undefined);
+
+        this._inputTypeStack.push(isInputType(itemType) ? itemType : undefined);
+
+        break;
+      }
+
+      case Kind.OBJECT_FIELD: {
+        const objectType = getNamedType(this.getInputType());
+        let inputFieldType;
+        let inputField;
+
+        if (isInputObjectType(objectType)) {
+          inputField = objectType.getFields()[node.name.value];
+
+          if (inputField) {
+            inputFieldType = inputField.type;
+          }
+        }
+
+        this._defaultValueStack.push(
+          inputField ? inputField.defaultValue : undefined,
+        );
+
+        this._inputTypeStack.push(
+          isInputType(inputFieldType) ? inputFieldType : undefined,
+        );
+
+        break;
+      }
+
+      case Kind.ENUM: {
+        const enumType = getNamedType(this.getInputType());
+        let enumValue;
+
+        if (isEnumType(enumType)) {
+          enumValue = enumType.getValue(node.value);
+        }
+
+        this._enumValue = enumValue;
+        break;
+      }
+
+      default: // Ignore other nodes
+    }
+  }
+
+  leave(node) {
+    switch (node.kind) {
+      case Kind.SELECTION_SET:
+        this._parentTypeStack.pop();
+
+        break;
+
+      case Kind.FIELD:
+        this._fieldDefStack.pop();
+
+        this._typeStack.pop();
+
+        break;
+
+      case Kind.DIRECTIVE:
+        this._directive = null;
+        break;
+
+      case Kind.OPERATION_DEFINITION:
+      case Kind.INLINE_FRAGMENT:
+      case Kind.FRAGMENT_DEFINITION:
+        this._typeStack.pop();
+
+        break;
+
+      case Kind.VARIABLE_DEFINITION:
+        this._inputTypeStack.pop();
+
+        break;
+
+      case Kind.ARGUMENT:
+        this._argument = null;
+
+        this._defaultValueStack.pop();
+
+        this._inputTypeStack.pop();
+
+        break;
+
+      case Kind.LIST:
+      case Kind.OBJECT_FIELD:
+        this._defaultValueStack.pop();
+
+        this._inputTypeStack.pop();
+
+        break;
+
+      case Kind.ENUM:
+        this._enumValue = null;
+        break;
+
+      default: // Ignore other nodes
+    }
+  }
+}
+
+/**
+ * Not exactly the same as the executor's definition of getFieldDef, in this
+ * statically evaluated environment we do not always have an Object type,
+ * and need to handle Interface and Union types.
+ */
+function getFieldDef(schema, parentType, fieldNode) {
+  const name = fieldNode.name.value;
+
+  if (
+    name === SchemaMetaFieldDef.name &&
+    schema.getQueryType() === parentType
+  ) {
+    return SchemaMetaFieldDef;
+  }
+
+  if (name === TypeMetaFieldDef.name && schema.getQueryType() === parentType) {
+    return TypeMetaFieldDef;
+  }
+
+  if (name === TypeNameMetaFieldDef.name && isCompositeType(parentType)) {
+    return TypeNameMetaFieldDef;
+  }
+
+  if (isObjectType(parentType) || isInterfaceType(parentType)) {
+    return parentType.getFields()[name];
+  }
+}
+/**
+ * Creates a new visitor instance which maintains a provided TypeInfo instance
+ * along with visiting visitor.
+ */
+
+export function visitWithTypeInfo(typeInfo, visitor) {
+  return {
+    enter(...args) {
+      const node = args[0];
+      typeInfo.enter(node);
+      const fn = getEnterLeaveForKind(visitor, node.kind).enter;
+
+      if (fn) {
+        const result = fn.apply(visitor, args);
+
+        if (result !== undefined) {
+          typeInfo.leave(node);
+
+          if (isNode(result)) {
+            typeInfo.enter(result);
+          }
+        }
+
+        return result;
+      }
+    },
+
+    leave(...args) {
+      const node = args[0];
+      const fn = getEnterLeaveForKind(visitor, node.kind).leave;
+      let result;
+
+      if (fn) {
+        result = fn.apply(visitor, args);
+      }
+
+      typeInfo.leave(node);
+      return result;
+    },
+  };
+}

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

@@ -0,0 +1,13 @@
+import { GraphQLError } from '../error/GraphQLError';
+/**
+ * Upholds the spec rules about naming.
+ * @deprecated Please use `assertName` instead. Will be removed in v17
+ */
+export declare function assertValidName(name: string): string;
+/**
+ * Returns an Error if a name is invalid.
+ * @deprecated Please use `assertName` instead. Will be removed in v17
+ */
+export declare function isValidNameError(
+  name: string,
+): GraphQLError | undefined;

package/node_modules/graphql/utilities/assertValidName.js

@@ -0,0 +1,51 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.assertValidName = assertValidName;
+exports.isValidNameError = isValidNameError;
+
+var _devAssert = require('../jsutils/devAssert.js');
+
+var _GraphQLError = require('../error/GraphQLError.js');
+
+var _assertName = require('../type/assertName.js');
+
+/* c8 ignore start */
+
+/**
+ * Upholds the spec rules about naming.
+ * @deprecated Please use `assertName` instead. Will be removed in v17
+ */
+function assertValidName(name) {
+  const error = isValidNameError(name);
+
+  if (error) {
+    throw error;
+  }
+
+  return name;
+}
+/**
+ * Returns an Error if a name is invalid.
+ * @deprecated Please use `assertName` instead. Will be removed in v17
+ */
+
+function isValidNameError(name) {
+  typeof name === 'string' ||
+    (0, _devAssert.devAssert)(false, 'Expected name to be a string.');
+
+  if (name.startsWith('__')) {
+    return new _GraphQLError.GraphQLError(
+      `Name "${name}" must not begin with "__", which is reserved by GraphQL introspection.`,
+    );
+  }
+
+  try {
+    (0, _assertName.assertName)(name);
+  } catch (error) {
+    return error;
+  }
+}
+/* c8 ignore stop */

package/node_modules/graphql/utilities/assertValidName.mjs

@@ -0,0 +1,40 @@
+import { devAssert } from '../jsutils/devAssert.mjs';
+import { GraphQLError } from '../error/GraphQLError.mjs';
+import { assertName } from '../type/assertName.mjs';
+/* c8 ignore start */
+
+/**
+ * Upholds the spec rules about naming.
+ * @deprecated Please use `assertName` instead. Will be removed in v17
+ */
+
+export function assertValidName(name) {
+  const error = isValidNameError(name);
+
+  if (error) {
+    throw error;
+  }
+
+  return name;
+}
+/**
+ * Returns an Error if a name is invalid.
+ * @deprecated Please use `assertName` instead. Will be removed in v17
+ */
+
+export function isValidNameError(name) {
+  typeof name === 'string' || devAssert(false, 'Expected name to be a string.');
+
+  if (name.startsWith('__')) {
+    return new GraphQLError(
+      `Name "${name}" must not begin with "__", which is reserved by GraphQL introspection.`,
+    );
+  }
+
+  try {
+    assertName(name);
+  } catch (error) {
+    return error;
+  }
+}
+/* c8 ignore stop */

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

@@ -0,0 +1,28 @@
+import type { Maybe } from '../jsutils/Maybe';
+import type { ValueNode } from '../language/ast';
+import type { GraphQLInputType } from '../type/definition';
+/**
+ * Produces a GraphQL Value AST given a JavaScript object.
+ * Function will match JavaScript/JSON values to GraphQL AST schema format
+ * by using suggested GraphQLInputType. For example:
+ *
+ *     astFromValue("value", GraphQLString)
+ *
+ * A GraphQL type must be provided, which will be used to interpret different
+ * JavaScript values.
+ *
+ * | JSON Value    | GraphQL Value        |
+ * | ------------- | -------------------- |
+ * | Object        | Input Object         |
+ * | Array         | List                 |
+ * | Boolean       | Boolean              |
+ * | String        | String / Enum Value  |
+ * | Number        | Int / Float          |
+ * | Unknown       | Enum Value           |
+ * | null          | NullValue            |
+ *
+ */
+export declare function astFromValue(
+  value: unknown,
+  type: GraphQLInputType,
+): Maybe<ValueNode>;

package/node_modules/graphql/utilities/astFromValue.js

@@ -0,0 +1,190 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.astFromValue = astFromValue;
+
+var _inspect = require('../jsutils/inspect.js');
+
+var _invariant = require('../jsutils/invariant.js');
+
+var _isIterableObject = require('../jsutils/isIterableObject.js');
+
+var _isObjectLike = require('../jsutils/isObjectLike.js');
+
+var _kinds = require('../language/kinds.js');
+
+var _definition = require('../type/definition.js');
+
+var _scalars = require('../type/scalars.js');
+
+/**
+ * Produces a GraphQL Value AST given a JavaScript object.
+ * Function will match JavaScript/JSON values to GraphQL AST schema format
+ * by using suggested GraphQLInputType. For example:
+ *
+ *     astFromValue("value", GraphQLString)
+ *
+ * A GraphQL type must be provided, which will be used to interpret different
+ * JavaScript values.
+ *
+ * | JSON Value    | GraphQL Value        |
+ * | ------------- | -------------------- |
+ * | Object        | Input Object         |
+ * | Array         | List                 |
+ * | Boolean       | Boolean              |
+ * | String        | String / Enum Value  |
+ * | Number        | Int / Float          |
+ * | Unknown       | Enum Value           |
+ * | null          | NullValue            |
+ *
+ */
+function astFromValue(value, type) {
+  if ((0, _definition.isNonNullType)(type)) {
+    const astValue = astFromValue(value, type.ofType);
+
+    if (
+      (astValue === null || astValue === void 0 ? void 0 : astValue.kind) ===
+      _kinds.Kind.NULL
+    ) {
+      return null;
+    }
+
+    return astValue;
+  } // only explicit null, not undefined, NaN
+
+  if (value === null) {
+    return {
+      kind: _kinds.Kind.NULL,
+    };
+  } // undefined
+
+  if (value === undefined) {
+    return null;
+  } // Convert JavaScript array to GraphQL list. If the GraphQLType is a list, but
+  // the value is not an array, convert the value using the list's item type.
+
+  if ((0, _definition.isListType)(type)) {
+    const itemType = type.ofType;
+
+    if ((0, _isIterableObject.isIterableObject)(value)) {
+      const valuesNodes = [];
+
+      for (const item of value) {
+        const itemNode = astFromValue(item, itemType);
+
+        if (itemNode != null) {
+          valuesNodes.push(itemNode);
+        }
+      }
+
+      return {
+        kind: _kinds.Kind.LIST,
+        values: valuesNodes,
+      };
+    }
+
+    return astFromValue(value, itemType);
+  } // Populate the fields of the input object by creating ASTs from each value
+  // in the JavaScript object according to the fields in the input type.
+
+  if ((0, _definition.isInputObjectType)(type)) {
+    if (!(0, _isObjectLike.isObjectLike)(value)) {
+      return null;
+    }
+
+    const fieldNodes = [];
+
+    for (const field of Object.values(type.getFields())) {
+      const fieldValue = astFromValue(value[field.name], field.type);
+
+      if (fieldValue) {
+        fieldNodes.push({
+          kind: _kinds.Kind.OBJECT_FIELD,
+          name: {
+            kind: _kinds.Kind.NAME,
+            value: field.name,
+          },
+          value: fieldValue,
+        });
+      }
+    }
+
+    return {
+      kind: _kinds.Kind.OBJECT,
+      fields: fieldNodes,
+    };
+  }
+
+  if ((0, _definition.isLeafType)(type)) {
+    // Since value is an internally represented value, it must be serialized
+    // to an externally represented value before converting into an AST.
+    const serialized = type.serialize(value);
+
+    if (serialized == null) {
+      return null;
+    } // Others serialize based on their corresponding JavaScript scalar types.
+
+    if (typeof serialized === 'boolean') {
+      return {
+        kind: _kinds.Kind.BOOLEAN,
+        value: serialized,
+      };
+    } // JavaScript numbers can be Int or Float values.
+
+    if (typeof serialized === 'number' && Number.isFinite(serialized)) {
+      const stringNum = String(serialized);
+      return integerStringRegExp.test(stringNum)
+        ? {
+            kind: _kinds.Kind.INT,
+            value: stringNum,
+          }
+        : {
+            kind: _kinds.Kind.FLOAT,
+            value: stringNum,
+          };
+    }
+
+    if (typeof serialized === 'string') {
+      // Enum types use Enum literals.
+      if ((0, _definition.isEnumType)(type)) {
+        return {
+          kind: _kinds.Kind.ENUM,
+          value: serialized,
+        };
+      } // ID types can use Int literals.
+
+      if (type === _scalars.GraphQLID && integerStringRegExp.test(serialized)) {
+        return {
+          kind: _kinds.Kind.INT,
+          value: serialized,
+        };
+      }
+
+      return {
+        kind: _kinds.Kind.STRING,
+        value: serialized,
+      };
+    }
+
+    throw new TypeError(
+      `Cannot convert value to AST: ${(0, _inspect.inspect)(serialized)}.`,
+    );
+  }
+  /* c8 ignore next 3 */
+  // Not reachable, all possible types have been considered.
+
+  false ||
+    (0, _invariant.invariant)(
+      false,
+      'Unexpected input type: ' + (0, _inspect.inspect)(type),
+    );
+}
+/**
+ * IntValue:
+ *   - NegativeSign? 0
+ *   - NegativeSign? NonZeroDigit ( Digit+ )?
+ */
+
+const integerStringRegExp = /^-?(?:0|[1-9][0-9]*)$/;