@nxgt/graphql-codegen-msw 0.0.0-stage → 0.1.0

package/dist/runtime/index.js

@@ -0,0 +1,595 @@
+// src/runtime/index.ts
+import {
+  fieldIssueOf as fieldIssueOf2,
+  fieldsError,
+  inputPath,
+  invalidInputError as invalidInputError2
+} from "@nxgt/graphql-validation";
+
+// src/runtime/mock-operation.ts
+import {
+  graphql
+} from "msw/graphql";
+
+// src/runtime/coercion/index.ts
+import { GraphQLError } from "graphql";
+
+// src/runtime/coercion/document.ts
+import {
+  Kind,
+  parse
+} from "graphql";
+function declared(source) {
+  const at = source.indexOf(" = ");
+  const printed = at === -1 ? source : source.slice(0, at);
+  return { type: typeRef(printed.trim()), hasDefault: at !== -1 };
+}
+function typeRef(printed) {
+  if (printed.endsWith("!"))
+    return { kind: "non-null", of: typeRef(printed.slice(0, -1)) };
+  if (printed.startsWith("[") && printed.endsWith("]"))
+    return { kind: "list", of: typeRef(printed.slice(1, -1)) };
+  return { kind: "named", name: printed };
+}
+function printType(type) {
+  switch (type.kind) {
+    case "non-null":
+      return `${printType(type.of)}!`;
+    case "list":
+      return `[${printType(type.of)}]`;
+    default:
+      return type.name;
+  }
+}
+function definitionsOf(query, name) {
+  let operations;
+  try {
+    operations = parse(query).definitions.filter((node) => node.kind === Kind.OPERATION_DEFINITION);
+  } catch {
+    return new Map;
+  }
+  const operation = operations.find((node) => node.name?.value === name) ?? operations[0];
+  return new Map((operation?.variableDefinitions ?? []).map((node) => [
+    node.variable.name.value,
+    node
+  ]));
+}
+
+// src/runtime/coercion/issues.ts
+function placed(issues, prefix = []) {
+  return issues.flatMap((issue) => {
+    const path = [...prefix, ...issue.path.map(segment)];
+    const own = { path, issue };
+    if (issue.code !== "invalid_union")
+      return [own];
+    return [own, ...issue.errors.flatMap((branch) => placed(branch, path))];
+  });
+}
+function segment(key) {
+  return typeof key === "number" ? key : String(key);
+}
+function issueAt(issues, path) {
+  return issues.find((placedIssue) => placedIssue.path.length >= path.length && path.every((key, index) => placedIssue.path[index] === key))?.issue;
+}
+
+// src/runtime/coercion/cross-inspect.ts
+/*!
+ * Ported from cross-inspect 1.0.1 (packages/inspect),
+ * https://github.com/ardatan/graphql-tools
+ * Copyright (c) 2020 The Guild, Inc.
+ * itself taken from graphql-js, https://github.com/graphql/graphql-js
+ * Copyright (c) GraphQL Contributors
+ * @license MIT
+ */
+function crossInspect(value) {
+  return formatValue(value, 0);
+}
+var MAX_DEPTH = 3;
+function formatValue(value, depth) {
+  if (typeof value === "string")
+    return JSON.stringify(value);
+  if (typeof value !== "object" || value === null)
+    return String(value);
+  if (Array.isArray(value)) {
+    if (value.length === 0)
+      return "[]";
+    if (depth >= MAX_DEPTH)
+      return "[Array]";
+    return `[${value.map((item) => formatValue(item, depth + 1)).join(", ")}]`;
+  }
+  const entries = Object.entries(value);
+  if (entries.length === 0)
+    return "{}";
+  if (depth >= MAX_DEPTH)
+    return "[Object]";
+  return `{ ${entries.map(([key, item]) => `${key}: ${formatValue(item, depth + 1)}`).join(", ")} }`;
+}
+
+// src/runtime/coercion/inspect.ts
+/*!
+ * Ported from graphql-js 17.0.2 (src/jsutils/inspect.ts),
+ * https://github.com/graphql/graphql-js
+ * Copyright (c) GraphQL Contributors
+ * @license MIT
+ */
+var MAX_ARRAY_LENGTH = 10;
+var MAX_RECURSIVE_DEPTH = 2;
+function inspect(value) {
+  return formatValue2(value, []);
+}
+function formatValue2(value, seenValues) {
+  switch (typeof value) {
+    case "string":
+      return JSON.stringify(value);
+    case "function":
+      return value.name ? `[function ${value.name}]` : "[function]";
+    case "object":
+      return formatObjectValue(value, seenValues);
+    default:
+      return String(value);
+  }
+}
+function formatObjectValue(value, previouslySeenValues) {
+  if (value === null) {
+    return "null";
+  }
+  if (previouslySeenValues.includes(value)) {
+    return "[Circular]";
+  }
+  const seenValues = [...previouslySeenValues, value];
+  if (isJSONable(value)) {
+    const jsonValue = value.toJSON();
+    if (jsonValue !== value) {
+      return typeof jsonValue === "string" ? jsonValue : formatValue2(jsonValue, seenValues);
+    }
+  } else if (Array.isArray(value)) {
+    return formatArray(value, seenValues);
+  }
+  return formatObject(value, seenValues);
+}
+function isJSONable(value) {
+  return typeof value.toJSON === "function";
+}
+function formatObject(object, seenValues) {
+  const entries = Object.entries(object);
+  if (entries.length === 0) {
+    return "{}";
+  }
+  if (seenValues.length > MAX_RECURSIVE_DEPTH) {
+    return `[${getObjectTag(object)}]`;
+  }
+  const properties = entries.map(([key, value]) => `${key}: ${formatValue2(value, seenValues)}`);
+  return `{ ${properties.join(", ")} }`;
+}
+function formatArray(array, seenValues) {
+  if (array.length === 0) {
+    return "[]";
+  }
+  if (seenValues.length > MAX_RECURSIVE_DEPTH) {
+    return "[Array]";
+  }
+  const len = Math.min(MAX_ARRAY_LENGTH, array.length);
+  const remaining = array.length - len;
+  const items = [];
+  for (let i = 0;i < len; ++i) {
+    items.push(formatValue2(array[i], seenValues));
+  }
+  if (remaining === 1) {
+    items.push("... 1 more item");
+  } else if (remaining > 1) {
+    items.push(`... ${remaining} more items`);
+  }
+  return `[${items.join(", ")}]`;
+}
+function getObjectTag(object) {
+  const tag = Object.prototype.toString.call(object).replace(/^\[object /, "").replace(/]$/, "");
+  if (tag === "Object" && typeof object.constructor === "function") {
+    const name = object.constructor.name;
+    if (typeof name === "string" && name !== "") {
+      return name;
+    }
+  }
+  return tag;
+}
+
+// src/runtime/coercion/suggestions.ts
+/*!
+ * Ported from graphql-js 17.0.2 (src/jsutils/suggestionList.ts,
+ * didYouMean.ts, formatList.ts, naturalCompare.ts),
+ * https://github.com/graphql/graphql-js
+ * Copyright (c) GraphQL Contributors
+ * @license MIT
+ */
+var MAX_SUGGESTIONS = 5;
+function didYouMean(suggestions, subject) {
+  if (suggestions.length === 0)
+    return "";
+  const listed = orList(suggestions.slice(0, MAX_SUGGESTIONS).map((item) => `"${item}"`));
+  return ` Did you mean ${subject ? `${subject} ` : ""}${listed}?`;
+}
+function orList(items) {
+  if (items.length === 1)
+    return items[0] ?? "";
+  if (items.length === 2)
+    return `${items[0]} or ${items[1]}`;
+  return `${items.slice(0, -1).join(", ")}, or ${items.at(-1)}`;
+}
+function suggestionList(input, options) {
+  const distances = new Map;
+  const threshold = Math.floor(input.length * 0.4) + 1;
+  for (const option of options) {
+    const distance = lexicalDistance(input, option, threshold);
+    if (distance !== undefined)
+      distances.set(option, distance);
+  }
+  return [...distances.keys()].sort((a, b) => (distances.get(a) ?? 0) - (distances.get(b) ?? 0) || naturalCompare(a, b));
+}
+function lexicalDistance(input, option, threshold) {
+  if (input === option)
+    return 0;
+  const lowerInput = input.toLowerCase();
+  const lowerOption = option.toLowerCase();
+  if (lowerInput === lowerOption)
+    return 1;
+  let a = codes(lowerOption);
+  let b = codes(lowerInput);
+  if (a.length < b.length)
+    [a, b] = [b, a];
+  if (a.length - b.length > threshold)
+    return;
+  const rows = [0, 1, 2].map(() => new Array(b.length + 1).fill(0));
+  const row = (i) => rows[i % 3];
+  for (let j = 0;j <= b.length; j++)
+    row(0)[j] = j;
+  for (let i = 1;i <= a.length; i++) {
+    const up = row(i - 1);
+    const current = row(i);
+    current[0] = i;
+    let smallest = i;
+    for (let j = 1;j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      let cell = Math.min((up[j] ?? 0) + 1, (current[j - 1] ?? 0) + 1, (up[j - 1] ?? 0) + cost);
+      if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1])
+        cell = Math.min(cell, (row(i - 2)[j - 2] ?? 0) + 1);
+      if (cell < smallest)
+        smallest = cell;
+      current[j] = cell;
+    }
+    if (smallest > threshold)
+      return;
+  }
+  const distance = row(a.length)[b.length] ?? 0;
+  return distance <= threshold ? distance : undefined;
+}
+function codes(text) {
+  return Array.from({ length: text.length }, (_, i) => text.charCodeAt(i));
+}
+var DIGIT_0 = 48;
+var DIGIT_9 = 57;
+var isDigit = (code) => !Number.isNaN(code) && DIGIT_0 <= code && code <= DIGIT_9;
+function naturalCompare(aText, bText) {
+  let a = 0;
+  let b = 0;
+  while (a < aText.length && b < bText.length) {
+    let aChar = aText.charCodeAt(a);
+    let bChar = bText.charCodeAt(b);
+    if (isDigit(aChar) && isDigit(bChar)) {
+      let aNumber = 0;
+      do {
+        ++a;
+        aNumber = aNumber * 10 + aChar - DIGIT_0;
+        aChar = aText.charCodeAt(a);
+      } while (isDigit(aChar) && aNumber > 0);
+      let bNumber = 0;
+      do {
+        ++b;
+        bNumber = bNumber * 10 + bChar - DIGIT_0;
+        bChar = bText.charCodeAt(b);
+      } while (isDigit(bChar) && bNumber > 0);
+      if (aNumber !== bNumber)
+        return aNumber < bNumber ? -1 : 1;
+    } else {
+      if (aChar !== bChar)
+        return aChar < bChar ? -1 : 1;
+      ++a;
+      ++b;
+    }
+  }
+  return aText.length - bText.length;
+}
+
+// src/runtime/coercion/messages.ts
+/*!
+ * Messages ported from graphql-js 17.0.2 (src/type/scalars.ts,
+ * src/type/definition.ts), https://github.com/graphql/graphql-js
+ * Copyright (c) GraphQL Contributors
+ * and from @graphql-tools/executor 2.0.3 (execution/validateInputValue,
+ * execution/values), https://github.com/ardatan/graphql-tools
+ * Copyright (c) 2020 The Guild, Inc.
+ * @license MIT
+ */
+var INT_MAX = 2147483647;
+var INT_MIN = -2147483648;
+function builtinRefusal(name, value) {
+  const found = inspect(value);
+  switch (name) {
+    case "String":
+      return typeof value === "string" ? undefined : `String cannot represent a non string value: ${found}`;
+    case "Boolean":
+      return typeof value === "boolean" ? undefined : `Boolean cannot represent a non boolean value: ${found}`;
+    case "Float":
+      return typeof value === "number" && Number.isFinite(value) ? undefined : `Float cannot represent non numeric value: ${found}`;
+    case "ID":
+      return typeof value === "string" || Number.isInteger(value) ? undefined : `ID cannot represent value: ${found}`;
+    case "Int":
+      return intRefusal(value);
+    default:
+      return;
+  }
+}
+function intRefusal(value) {
+  if (typeof value !== "number" || !Number.isInteger(value))
+    return `Int cannot represent non-integer value: ${inspect(value)}`;
+  if (value > INT_MAX || value < INT_MIN)
+    return `Int cannot represent non 32-bit signed integer value: ${inspect(value)}`;
+  return;
+}
+function enumRefusal(name, values, value) {
+  if (typeof value !== "string") {
+    const found = inspect(value);
+    return `Enum "${name}" cannot represent non-string value: ${found}.${suggest(found, values)}`;
+  }
+  if (values.includes(value))
+    return;
+  return `Value "${value}" does not exist in "${name}" enum.${suggest(value, values)}`;
+}
+function suggest(value, values) {
+  return didYouMean(suggestionList(value, values), "the enum value");
+}
+function scalarRefusal(name, issue) {
+  return issue && `${name} cannot represent this input: ${issue.message}`;
+}
+var objectRefusal = {
+  notAnObject: (type, value) => `Expected value of type "${type}" to be an object, found: ${crossInspect(value)}.`,
+  missingField: (type, field, object) => `Expected value of type "${type}" to include required field "${field}", found: ${crossInspect(object)}.`,
+  unknownField: (type, field, known, object) => {
+    const suggestion = didYouMean(suggestionList(field, known));
+    return `Expected value of type "${type}" not to include unknown field "${field}"${suggestion ? `.${suggestion} Found` : ", found"}: ${crossInspect(object)}.`;
+  },
+  oneOf: (type) => `Within OneOf Input Object type "${type}", exactly one field must be specified, and the value for that field must be non-null.`,
+  notProvided: (type) => `Expected a value of non-null type "${type}" to be provided.`,
+  isNull: (type) => `Expected value of non-null type "${type}" not to be null.`
+};
+var variableRefusal = {
+  notProvided: (name, type) => `Variable "$${name}" of required type "${type}" was not provided.`,
+  isNull: (name, type) => `Variable "$${name}" of non-null type "${type}" must not be null.`,
+  invalidValue: (name, value, path, reason) => {
+    const at = path.length > 0 ? ` at "${name}${path.map((key) => typeof key === "number" ? `[${key}]` : `.${key}`).join("")}"` : "";
+    return `Variable "$${name}" got invalid value ${crossInspect(value)}${at}; ${reason}`;
+  }
+};
+
+// src/runtime/coercion/validate.ts
+/*!
+ * Ported from @graphql-tools/executor 2.0.3 (execution/validateInputValue),
+ * https://github.com/ardatan/graphql-tools
+ * Copyright (c) 2020 The Guild, Inc.
+ * itself a copy of graphql-js 17's validateInputValue,
+ * https://github.com/graphql/graphql-js
+ * Copyright (c) GraphQL Contributors
+ * @license MIT
+ */
+function validateValue(walk, value, type, at) {
+  if (type.kind === "non-null") {
+    if (value === undefined)
+      report(walk, at, value, objectRefusal.notProvided(printType(type)));
+    else if (value === null)
+      report(walk, at, value, objectRefusal.isNull(printType(type)));
+    else
+      validateValue(walk, value, type.of, at);
+  } else if (value === null || value === undefined) {} else if (type.kind === "list") {
+    validateList(walk, value, type.of, at);
+  } else {
+    validateNamed(walk, value, type.name, at);
+  }
+}
+function validateList(walk, value, item, at) {
+  if (!Array.isArray(value)) {
+    validateValue(walk, value, item, { ...at, zodPath: [...at.zodPath, 0] });
+    return;
+  }
+  value.forEach((element, index) => {
+    validateValue(walk, element, item, {
+      path: [...at.path, index],
+      zodPath: [...at.zodPath, index]
+    });
+  });
+}
+var BUILT_INS = new Set([
+  "String",
+  "Int",
+  "Float",
+  "Boolean",
+  "ID"
+]);
+function validateNamed(walk, value, name, at) {
+  const named = walk.types[name] ?? (BUILT_INS.has(name) ? { kind: "builtin" } : { kind: "scalar" });
+  if (named.kind === "input") {
+    validateObject(walk, value, name, named, at);
+    return;
+  }
+  const reason = leafRefusal(walk, value, name, named, at);
+  if (reason !== undefined)
+    report(walk, at, value, reason);
+}
+function leafRefusal(walk, value, name, named, at) {
+  switch (named.kind) {
+    case "builtin":
+      return builtinRefusal(name, value);
+    case "enum":
+      return enumRefusal(name, named.values, value);
+    case "scalar":
+      return scalarRefusal(name, issueAt(walk.issues, at.zodPath));
+    default:
+      throw new Error(STALE_FILE);
+  }
+}
+var STALE_FILE = "@nxgt/graphql-codegen-msw: the generated file was written by another version than the runtime; regenerate it";
+function validateObject(walk, value, name, type, at) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    report(walk, at, value, objectRefusal.notAnObject(name, value));
+    return;
+  }
+  const object = value;
+  for (const [field, source] of Object.entries(type.fields)) {
+    const { type: fieldType, hasDefault } = declared(source);
+    const fieldValue = Object.hasOwn(object, field) ? object[field] : undefined;
+    if (fieldValue !== undefined)
+      validateValue(walk, fieldValue, fieldType, {
+        path: [...at.path, field],
+        zodPath: [...at.zodPath, field]
+      });
+    else if (fieldType.kind === "non-null" && !hasDefault)
+      report(walk, at, object, objectRefusal.missingField(name, field, object));
+  }
+  const names = Object.keys(type.fields);
+  const known = [];
+  for (const key of Object.keys(object)) {
+    if (object[key] === undefined)
+      continue;
+    if (Object.hasOwn(type.fields, key))
+      known.push(key);
+    else
+      report(walk, at, object, objectRefusal.unknownField(name, key, names, object));
+  }
+  if (type.oneOf)
+    validateOneOf(walk, object, name, known, at);
+}
+function validateOneOf(walk, object, name, known, at) {
+  const [only] = known;
+  if (known.length !== 1 || only === undefined)
+    report(walk, at, object, objectRefusal.oneOf(name));
+  else if (object[only] === null)
+    report(walk, { ...at, path: [...at.path, only] }, object, objectRefusal.oneOf(name));
+}
+function report(walk, at, value, reason) {
+  walk.problems.push({ path: at.path, value, reason });
+}
+
+// src/runtime/coercion/index.ts
+var COERCION_STATUS = 400;
+function coercionErrors(issues, request, operation) {
+  const definitions = definitionsOf(request.query, request.operationName);
+  const sent = typeof request.variables === "object" && request.variables !== null ? request.variables : {};
+  const walked = placed(issues);
+  const { variableTypes = {}, inputTypes = {} } = operation;
+  return Object.entries(variableTypes).flatMap(([name, source]) => variableMessages(name, source, sent, {
+    types: inputTypes,
+    issues: walked,
+    problems: []
+  }).map((message) => located(message, definitions.get(name))));
+}
+function variableMessages(name, source, sent, walk) {
+  const { type, hasDefault } = declared(source);
+  if (!Object.hasOwn(sent, name))
+    return type.kind === "non-null" && !hasDefault ? [variableRefusal.notProvided(name, printType(type))] : [];
+  const value = sent[name];
+  if (value === null && type.kind === "non-null")
+    return [variableRefusal.isNull(name, printType(type))];
+  validateValue(walk, value, type, { path: [], zodPath: [name] });
+  return walk.problems.map(({ path, value: found, reason }) => variableRefusal.invalidValue(name, found, path, reason));
+}
+function located(message, definition) {
+  return new GraphQLError(message, definition ? { nodes: definition } : {}).toJSON();
+}
+
+// src/runtime/response.ts
+import { HttpResponse } from "msw";
+function isGraphQLError(value) {
+  return value instanceof Error && (value.name === "GraphQLError" || Object.prototype.toString.call(value) === "[object GraphQLError]") && typeof value.toJSON === "function";
+}
+function formatted(error) {
+  const json = isGraphQLError(error) ? error.toJSON() : error;
+  const { extensions, ...rest } = json;
+  if (extensions === undefined)
+    return json;
+  const { http: _http, unexpected: _unexpected, ...kept } = extensions;
+  return Object.keys(kept).length > 0 ? { ...rest, extensions: kept } : rest;
+}
+function validStatus(status) {
+  return typeof status === "number" && Number.isInteger(status) && status >= 200 && status <= 599 && status !== 204 && status !== 205 && status !== 304 ? status : undefined;
+}
+function statusOf(error) {
+  const http = error.extensions?.http;
+  return validStatus(http?.status);
+}
+function errorResponse(error, init = {}) {
+  const errors = Array.isArray(error) ? error : [error];
+  const statuses = errors.map(statusOf).filter((status) => status !== undefined);
+  const status = validStatus(init.status) ?? (statuses.length > 0 ? Math.max(...statuses) : 200);
+  return HttpResponse.json({ errors: errors.map(formatted) }, { status });
+}
+
+// src/runtime/mock-operation.ts
+function mockOperation(operation, resolver, options = {}) {
+  const { endpoint = operation.endpoint, ...handlerOptions } = options;
+  const link = graphql.link(endpoint);
+  const where = { type: operation.type, name: operation.name };
+  return link[operation.type](operation.name, async (info) => {
+    const checked = await operation.variables.safeParseAsync(info.variables);
+    if (!checked.success) {
+      const { issues } = checked.error;
+      const refused = coercionErrors(issues, info, operation);
+      if (refused.length > 0)
+        return errorResponse(refused, { status: COERCION_STATUS });
+      const { error, status } = await operation.invalidInput(issues, where);
+      return errorResponse(error, { status });
+    }
+    try {
+      const answer = await resolver(info);
+      assertNotIterator(answer, operation.name);
+      return answer;
+    } catch (error) {
+      if (isGraphQLError(error))
+        return errorResponse(error);
+      throw error;
+    }
+  }, handlerOptions);
+}
+function assertNotIterator(answer, name) {
+  if (typeof answer === "object" && answer !== null && !(answer instanceof Response) && typeof answer.next === "function") {
+    throw new TypeError(`@nxgt/graphql-codegen-msw: the resolver of ${name} returned an iterator (a generator function?). Each request's variables are checked before the resolver runs, which msw cannot do once it keeps an iterator: answer each request from a plain function, or register one handler per answer with { once: true }.`);
+  }
+}
+// src/runtime/refusals.ts
+import {
+  badUserInput,
+  fieldIssueOf,
+  invalidInputError
+} from "@nxgt/graphql-validation";
+import { z } from "zod";
+function invalidInputRefusal(options = {}) {
+  const { translate } = options;
+  return (issues) => ({
+    error: invalidInputError(issues.map(fieldIssueOf), translate ? { translate } : {}),
+    status: 400
+  });
+}
+var badUserInputRefusal = (issues, operation) => ({
+  error: badUserInput(operation.name, new z.ZodError([...issues])),
+  status: 200
+});
+export {
+  badUserInputRefusal,
+  errorResponse,
+  fieldIssueOf2 as fieldIssueOf,
+  fieldsError,
+  inputPath,
+  invalidInputError2 as invalidInputError,
+  invalidInputRefusal,
+  isGraphQLError,
+  mockOperation
+};
+
+//# debugId=A8F75623BD88F85364756E2164756E21
+//# sourceMappingURL=index.js.map