graphql 0.0.1-test.1

package/language/visitor.mjs

@@ -0,0 +1,361 @@
+import { devAssert } from '../jsutils/devAssert.mjs';
+import { inspect } from '../jsutils/inspect.mjs';
+import { isNode, QueryDocumentKeys } from './ast.mjs';
+import { Kind } from './kinds.mjs';
+/**
+ * A visitor is provided to visit, it contains the collection of
+ * relevant functions to be called during the visitor's traversal.
+ */
+
+export const BREAK = Object.freeze({});
+/**
+ * visit() will walk through an AST using a depth-first traversal, calling
+ * the visitor's enter function at each node in the traversal, and calling the
+ * leave function after visiting that node and all of its child nodes.
+ *
+ * By returning different values from the enter and leave functions, the
+ * behavior of the visitor can be altered, including skipping over a sub-tree of
+ * the AST (by returning false), editing the AST by returning a value or null
+ * to remove the value, or to stop the whole traversal by returning BREAK.
+ *
+ * When using visit() to edit an AST, the original AST will not be modified, and
+ * a new version of the AST with the changes applied will be returned from the
+ * visit function.
+ *
+ * ```ts
+ * const editedAST = visit(ast, {
+ *   enter(node, key, parent, path, ancestors) {
+ *     // @return
+ *     //   undefined: no action
+ *     //   false: skip visiting this node
+ *     //   visitor.BREAK: stop visiting altogether
+ *     //   null: delete this node
+ *     //   any value: replace this node with the returned value
+ *   },
+ *   leave(node, key, parent, path, ancestors) {
+ *     // @return
+ *     //   undefined: no action
+ *     //   false: no action
+ *     //   visitor.BREAK: stop visiting altogether
+ *     //   null: delete this node
+ *     //   any value: replace this node with the returned value
+ *   }
+ * });
+ * ```
+ *
+ * Alternatively to providing enter() and leave() functions, a visitor can
+ * instead provide functions named the same as the kinds of AST nodes, or
+ * enter/leave visitors at a named key, leading to three permutations of the
+ * visitor API:
+ *
+ * 1) Named visitors triggered when entering a node of a specific kind.
+ *
+ * ```ts
+ * visit(ast, {
+ *   Kind(node) {
+ *     // enter the "Kind" node
+ *   }
+ * })
+ * ```
+ *
+ * 2) Named visitors that trigger upon entering and leaving a node of a specific kind.
+ *
+ * ```ts
+ * visit(ast, {
+ *   Kind: {
+ *     enter(node) {
+ *       // enter the "Kind" node
+ *     }
+ *     leave(node) {
+ *       // leave the "Kind" node
+ *     }
+ *   }
+ * })
+ * ```
+ *
+ * 3) Generic visitors that trigger upon entering and leaving any node.
+ *
+ * ```ts
+ * visit(ast, {
+ *   enter(node) {
+ *     // enter any node
+ *   },
+ *   leave(node) {
+ *     // leave any node
+ *   }
+ * })
+ * ```
+ */
+
+export function visit(root, visitor, visitorKeys = QueryDocumentKeys) {
+  const enterLeaveMap = new Map();
+
+  for (const kind of Object.values(Kind)) {
+    enterLeaveMap.set(kind, getEnterLeaveForKind(visitor, kind));
+  }
+  /* eslint-disable no-undef-init */
+
+  let stack = undefined;
+  let inArray = Array.isArray(root);
+  let keys = [root];
+  let index = -1;
+  let edits = [];
+  let node = root;
+  let key = undefined;
+  let parent = undefined;
+  const path = [];
+  const ancestors = [];
+  /* eslint-enable no-undef-init */
+
+  do {
+    index++;
+    const isLeaving = index === keys.length;
+    const isEdited = isLeaving && edits.length !== 0;
+
+    if (isLeaving) {
+      key = ancestors.length === 0 ? undefined : path[path.length - 1];
+      node = parent;
+      parent = ancestors.pop();
+
+      if (isEdited) {
+        if (inArray) {
+          node = node.slice();
+          let editOffset = 0;
+
+          for (const [editKey, editValue] of edits) {
+            const arrayKey = editKey - editOffset;
+
+            if (editValue === null) {
+              node.splice(arrayKey, 1);
+              editOffset++;
+            } else {
+              node[arrayKey] = editValue;
+            }
+          }
+        } else {
+          node = Object.defineProperties(
+            {},
+            Object.getOwnPropertyDescriptors(node),
+          );
+
+          for (const [editKey, editValue] of edits) {
+            node[editKey] = editValue;
+          }
+        }
+      }
+
+      index = stack.index;
+      keys = stack.keys;
+      edits = stack.edits;
+      inArray = stack.inArray;
+      stack = stack.prev;
+    } else if (parent) {
+      key = inArray ? index : keys[index];
+      node = parent[key];
+
+      if (node === null || node === undefined) {
+        continue;
+      }
+
+      path.push(key);
+    }
+
+    let result;
+
+    if (!Array.isArray(node)) {
+      var _enterLeaveMap$get, _enterLeaveMap$get2;
+
+      isNode(node) || devAssert(false, `Invalid AST Node: ${inspect(node)}.`);
+      const visitFn = isLeaving
+        ? (_enterLeaveMap$get = enterLeaveMap.get(node.kind)) === null ||
+          _enterLeaveMap$get === void 0
+          ? void 0
+          : _enterLeaveMap$get.leave
+        : (_enterLeaveMap$get2 = enterLeaveMap.get(node.kind)) === null ||
+          _enterLeaveMap$get2 === void 0
+        ? void 0
+        : _enterLeaveMap$get2.enter;
+      result =
+        visitFn === null || visitFn === void 0
+          ? void 0
+          : visitFn.call(visitor, node, key, parent, path, ancestors);
+
+      if (result === BREAK) {
+        break;
+      }
+
+      if (result === false) {
+        if (!isLeaving) {
+          path.pop();
+          continue;
+        }
+      } else if (result !== undefined) {
+        edits.push([key, result]);
+
+        if (!isLeaving) {
+          if (isNode(result)) {
+            node = result;
+          } else {
+            path.pop();
+            continue;
+          }
+        }
+      }
+    }
+
+    if (result === undefined && isEdited) {
+      edits.push([key, node]);
+    }
+
+    if (isLeaving) {
+      path.pop();
+    } else {
+      var _node$kind;
+
+      stack = {
+        inArray,
+        index,
+        keys,
+        edits,
+        prev: stack,
+      };
+      inArray = Array.isArray(node);
+      keys = inArray
+        ? node
+        : (_node$kind = visitorKeys[node.kind]) !== null &&
+          _node$kind !== void 0
+        ? _node$kind
+        : [];
+      index = -1;
+      edits = [];
+
+      if (parent) {
+        ancestors.push(parent);
+      }
+
+      parent = node;
+    }
+  } while (stack !== undefined);
+
+  if (edits.length !== 0) {
+    // New root
+    return edits[edits.length - 1][1];
+  }
+
+  return root;
+}
+/**
+ * Creates a new visitor instance which delegates to many visitors to run in
+ * parallel. Each visitor will be visited for each node before moving on.
+ *
+ * If a prior visitor edits a node, no following visitors will see that node.
+ */
+
+export function visitInParallel(visitors) {
+  const skipping = new Array(visitors.length).fill(null);
+  const mergedVisitor = Object.create(null);
+
+  for (const kind of Object.values(Kind)) {
+    let hasVisitor = false;
+    const enterList = new Array(visitors.length).fill(undefined);
+    const leaveList = new Array(visitors.length).fill(undefined);
+
+    for (let i = 0; i < visitors.length; ++i) {
+      const { enter, leave } = getEnterLeaveForKind(visitors[i], kind);
+      hasVisitor || (hasVisitor = enter != null || leave != null);
+      enterList[i] = enter;
+      leaveList[i] = leave;
+    }
+
+    if (!hasVisitor) {
+      continue;
+    }
+
+    const mergedEnterLeave = {
+      enter(...args) {
+        const node = args[0];
+
+        for (let i = 0; i < visitors.length; i++) {
+          if (skipping[i] === null) {
+            var _enterList$i;
+
+            const result =
+              (_enterList$i = enterList[i]) === null || _enterList$i === void 0
+                ? void 0
+                : _enterList$i.apply(visitors[i], args);
+
+            if (result === false) {
+              skipping[i] = node;
+            } else if (result === BREAK) {
+              skipping[i] = BREAK;
+            } else if (result !== undefined) {
+              return result;
+            }
+          }
+        }
+      },
+
+      leave(...args) {
+        const node = args[0];
+
+        for (let i = 0; i < visitors.length; i++) {
+          if (skipping[i] === null) {
+            var _leaveList$i;
+
+            const result =
+              (_leaveList$i = leaveList[i]) === null || _leaveList$i === void 0
+                ? void 0
+                : _leaveList$i.apply(visitors[i], args);
+
+            if (result === BREAK) {
+              skipping[i] = BREAK;
+            } else if (result !== undefined && result !== false) {
+              return result;
+            }
+          } else if (skipping[i] === node) {
+            skipping[i] = null;
+          }
+        }
+      },
+    };
+    mergedVisitor[kind] = mergedEnterLeave;
+  }
+
+  return mergedVisitor;
+}
+/**
+ * Given a visitor instance and a node kind, return EnterLeaveVisitor for that kind.
+ */
+
+export function getEnterLeaveForKind(visitor, kind) {
+  const kindVisitor = visitor[kind];
+
+  if (typeof kindVisitor === 'object') {
+    // { Kind: { enter() {}, leave() {} } }
+    return kindVisitor;
+  } else if (typeof kindVisitor === 'function') {
+    // { Kind() {} }
+    return {
+      enter: kindVisitor,
+      leave: undefined,
+    };
+  } // { enter() {}, leave() {} }
+
+  return {
+    enter: visitor.enter,
+    leave: visitor.leave,
+  };
+}
+/**
+ * Given a visitor instance, if it is leaving or not, and a node kind, return
+ * the function the visitor runtime should call.
+ *
+ * @deprecated Please use `getEnterLeaveForKind` instead. Will be removed in v17
+ */
+
+/* c8 ignore next 8 */
+
+export function getVisitFn(visitor, kind, isLeaving) {
+  const { enter, leave } = getEnterLeaveForKind(visitor, kind);
+  return isLeaving ? leave : enter;
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "graphql",
+  "version": "0.0.1-test.1",
+  "description": "A Query Language and Runtime which can target any service.",
+  "license": "MIT",
+  "main": "index",
+  "module": "index.mjs",
+  "typesVersions": {
+    ">=4.1.0": {
+      "*": [
+        "*"
+      ]
+    },
+    "*": {
+      "*": [
+        "NotSupportedTSVersion.d.ts"
+      ]
+    }
+  },
+  "sideEffects": false,
+  "homepage": "https://github.com/graphql/graphql-js",
+  "bugs": {
+    "url": "https://github.com/graphql/graphql-js/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/graphql/graphql-js.git"
+  },
+  "keywords": [
+    "graphql",
+    "graphql-js"
+  ],
+  "engines": {
+    "node": "^12.22.0 || ^14.16.0 || >=16.0.0"
+  },
+  "publishConfig": {
+    "tag": "test3"
+  },
+  "deprecated": "Test version of a package"
+}

package/subscription/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * NOTE: the `graphql/subscription` module has been deprecated with its
+ * exported functions integrated into the `graphql/execution` module, to
+ * better conform with the terminology of the GraphQL specification.
+ *
+ * For backwards compatibility, the `graphql/subscription` module
+ * currently re-exports the moved functions from the `graphql/execution`
+ * module. In the next major release, the `graphql/subscription` module
+ * will be dropped entirely.
+ */
+import type { ExecutionArgs } from '../execution/execute';
+/**
+ * @deprecated use ExecutionArgs instead. Will be removed in v17
+ *
+ * ExecutionArgs has been broadened to include all properties within SubscriptionArgs.
+ * The SubscriptionArgs type is retained for backwards compatibility.
+ */
+export interface SubscriptionArgs extends ExecutionArgs {}
+export { subscribe, createSourceEventStream } from '../execution/subscribe';

package/subscription/index.js

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+Object.defineProperty(exports, 'createSourceEventStream', {
+  enumerable: true,
+  get: function () {
+    return _subscribe.createSourceEventStream;
+  },
+});
+Object.defineProperty(exports, 'subscribe', {
+  enumerable: true,
+  get: function () {
+    return _subscribe.subscribe;
+  },
+});
+
+var _subscribe = require('../execution/subscribe.js');

package/subscription/index.mjs

@@ -0,0 +1,19 @@
+/**
+ * NOTE: the `graphql/subscription` module has been deprecated with its
+ * exported functions integrated into the `graphql/execution` module, to
+ * better conform with the terminology of the GraphQL specification.
+ *
+ * For backwards compatibility, the `graphql/subscription` module
+ * currently re-exports the moved functions from the `graphql/execution`
+ * module. In the next major release, the `graphql/subscription` module
+ * will be dropped entirely.
+ */
+
+/**
+ * @deprecated use ExecutionArgs instead. Will be removed in v17
+ *
+ * ExecutionArgs has been broadened to include all properties within SubscriptionArgs.
+ * The SubscriptionArgs type is retained for backwards compatibility.
+ */
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export { subscribe, createSourceEventStream } from '../execution/subscribe.mjs';

package/type/assertName.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Upholds the spec rules about naming.
+ */
+export declare function assertName(name: string): string;
+/**
+ * Upholds the spec rules about naming enum values.
+ *
+ * @internal
+ */
+export declare function assertEnumValueName(name: string): string;

package/type/assertName.js

@@ -0,0 +1,59 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.assertEnumValueName = assertEnumValueName;
+exports.assertName = assertName;
+
+var _devAssert = require('../jsutils/devAssert.js');
+
+var _GraphQLError = require('../error/GraphQLError.js');
+
+var _characterClasses = require('../language/characterClasses.js');
+
+/**
+ * Upholds the spec rules about naming.
+ */
+function assertName(name) {
+  name != null || (0, _devAssert.devAssert)(false, 'Must provide name.');
+  typeof name === 'string' ||
+    (0, _devAssert.devAssert)(false, 'Expected name to be a string.');
+
+  if (name.length === 0) {
+    throw new _GraphQLError.GraphQLError(
+      'Expected name to be a non-empty string.',
+    );
+  }
+
+  for (let i = 1; i < name.length; ++i) {
+    if (!(0, _characterClasses.isNameContinue)(name.charCodeAt(i))) {
+      throw new _GraphQLError.GraphQLError(
+        `Names must only contain [_a-zA-Z0-9] but "${name}" does not.`,
+      );
+    }
+  }
+
+  if (!(0, _characterClasses.isNameStart)(name.charCodeAt(0))) {
+    throw new _GraphQLError.GraphQLError(
+      `Names must start with [_a-zA-Z] but "${name}" does not.`,
+    );
+  }
+
+  return name;
+}
+/**
+ * Upholds the spec rules about naming enum values.
+ *
+ * @internal
+ */
+
+function assertEnumValueName(name) {
+  if (name === 'true' || name === 'false' || name === 'null') {
+    throw new _GraphQLError.GraphQLError(
+      `Enum values cannot be named: ${name}`,
+    );
+  }
+
+  return assertName(name);
+}

package/type/assertName.mjs

@@ -0,0 +1,44 @@
+import { devAssert } from '../jsutils/devAssert.mjs';
+import { GraphQLError } from '../error/GraphQLError.mjs';
+import { isNameContinue, isNameStart } from '../language/characterClasses.mjs';
+/**
+ * Upholds the spec rules about naming.
+ */
+
+export function assertName(name) {
+  name != null || devAssert(false, 'Must provide name.');
+  typeof name === 'string' || devAssert(false, 'Expected name to be a string.');
+
+  if (name.length === 0) {
+    throw new GraphQLError('Expected name to be a non-empty string.');
+  }
+
+  for (let i = 1; i < name.length; ++i) {
+    if (!isNameContinue(name.charCodeAt(i))) {
+      throw new GraphQLError(
+        `Names must only contain [_a-zA-Z0-9] but "${name}" does not.`,
+      );
+    }
+  }
+
+  if (!isNameStart(name.charCodeAt(0))) {
+    throw new GraphQLError(
+      `Names must start with [_a-zA-Z] but "${name}" does not.`,
+    );
+  }
+
+  return name;
+}
+/**
+ * Upholds the spec rules about naming enum values.
+ *
+ * @internal
+ */
+
+export function assertEnumValueName(name) {
+  if (name === 'true' || name === 'false' || name === 'null') {
+    throw new GraphQLError(`Enum values cannot be named: ${name}`);
+  }
+
+  return assertName(name);
+}