@nxgt/graphql-validation 0.5.0 → 0.7.0

package/dist/index.js

@@ -1,10 +1,10 @@
 import {
   constraintOf,
   constraintTypeDefs2
-} from "./chunks/index-xcaf9kes.js";
+} from "./chunks/index-atwkcfg3.js";
 import {
   checkConstraints2
-} from "./chunks/index-twevz7yc.js";
+} from "./chunks/index-w9pw7fsk.js";
 
 // src/bad-user-input.ts
 import { GraphQLError } from "graphql";
@@ -12,7 +12,13 @@ function issuesOf(error, constraintOf) {
   return error.issues.map((issue) => {
     const path = issue.path.map((key) => typeof key === "number" ? key : String(key));
     const constraint = constraintOf?.(issue);
-    return constraint ? { path, message: issue.message, code: issue.code, constraint } : { path, message: issue.message, code: issue.code };
+    return constraint ? {
+      path,
+      message: issue.message,
+      code: issue.code,
+      constraint: constraint.argument,
+      value: constraint.value
+    } : { path, message: issue.message, code: issue.code };
   });
 }
 function errorOf(where, issues) {
@@ -125,6 +131,477 @@ function codeOf(issue) {
       return FIELD_CODES.invalid;
   }
 }
+// src/limits/max-depth.ts
+import {
+  GraphQLError as GraphQLError3
+} from "graphql";
+
+// src/limits/describe.ts
+function operationLabel(operation) {
+  return operation.name ? `Operation "${operation.name.value}"` : "Operation";
+}
+function assertInteger(option, value, min, max = Number.MAX_SAFE_INTEGER) {
+  if (!Number.isInteger(value) || value < min || value >= max) {
+    throw new RangeError(`${option} must be an integer from ${min} to ${max - 1}.`);
+  }
+}
+
+// src/limits/introspection.ts
+import {
+  isEnumType,
+  isInputObjectType,
+  isInterfaceType,
+  isObjectType,
+  isUnionType,
+  SchemaMetaFieldDef,
+  TypeMetaFieldDef
+} from "graphql";
+function isIntrospectionRoot(name) {
+  return name === "__schema" || name === "__type";
+}
+function introspectionRoot(name) {
+  if (name === "__schema")
+    return SchemaMetaFieldDef;
+  if (name === "__type")
+    return TypeMetaFieldDef;
+  return;
+}
+var largest = new WeakMap;
+var typeCounts = new WeakMap;
+function typeCount(schema) {
+  let count = typeCounts.get(schema);
+  if (count === undefined) {
+    count = Object.keys(schema.getTypeMap()).length;
+    typeCounts.set(schema, count);
+  }
+  return count;
+}
+function largestCount(schema) {
+  const known = largest.get(schema);
+  if (known !== undefined)
+    return known;
+  let max = schema.getDirectives().length;
+  for (const directive of schema.getDirectives()) {
+    max = Math.max(max, directive.args.length, directive.locations.length);
+  }
+  for (const type of Object.values(schema.getTypeMap())) {
+    max = Math.max(max, countsOf(schema, type));
+  }
+  largest.set(schema, max);
+  return max;
+}
+function countsOf(schema, type) {
+  if (isObjectType(type) || isInterfaceType(type)) {
+    const fields = Object.values(type.getFields());
+    return Math.max(fields.length, type.getInterfaces().length, isInterfaceType(type) ? schema.getPossibleTypes(type).length : 0, ...fields.map((field) => field.args.length));
+  }
+  if (isInputObjectType(type))
+    return Object.keys(type.getFields()).length;
+  if (isEnumType(type))
+    return type.getValues().length;
+  if (isUnionType(type))
+    return type.getTypes().length;
+  return 0;
+}
+function introspectionSize(schema, field) {
+  return field === "types" ? typeCount(schema) : largestCount(schema);
+}
+
+// src/limits/max-depth.ts
+function depthOf(depth, selectionSet) {
+  let deepest = 0;
+  for (const selection of selectionSet.selections) {
+    let here = 0;
+    if (selection.kind === "Field") {
+      const name = selection.name.value;
+      if (name === "__typename")
+        continue;
+      if (depth.ignoreIntrospection && isIntrospectionRoot(name))
+        continue;
+      here = 1 + (selection.selectionSet ? depthOf(depth, selection.selectionSet) : 0);
+    } else if (selection.kind === "InlineFragment") {
+      here = depthOf(depth, selection.selectionSet);
+    } else {
+      here = fragmentDepth(depth, selection.name.value);
+    }
+    if (here > deepest)
+      deepest = here;
+  }
+  return deepest;
+}
+function fragmentDepth(depth, name) {
+  const known = depth.fragmentDepths.get(name);
+  if (known !== undefined)
+    return known;
+  const fragment = depth.getFragment(name);
+  if (!fragment || depth.measuring.has(name))
+    return 0;
+  depth.measuring.add(name);
+  const result = depthOf(depth, fragment.selectionSet);
+  depth.measuring.delete(name);
+  depth.fragmentDepths.set(name, result);
+  return result;
+}
+function maxDepth(options) {
+  const limit = options.depth;
+  assertInteger("maxDepth: depth", limit, 1);
+  return (context) => {
+    const walk = {
+      getFragment: (name) => context.getFragment(name),
+      fragmentDepths: new Map,
+      measuring: new Set,
+      ignoreIntrospection: options.ignoreIntrospection ?? false
+    };
+    return {
+      OperationDefinition(operation) {
+        const depth = depthOf(walk, operation.selectionSet);
+        if (depth > limit) {
+          context.reportError(new GraphQLError3(`${operationLabel(operation)} is ${depth} levels deep, more than the ${limit} allowed`, {
+            nodes: [operation],
+            extensions: { code: "QUERY_TOO_DEEP", depth, limit }
+          }));
+        }
+        return false;
+      }
+    };
+  };
+}
+// src/limits/max-fields.ts
+import {
+  GraphQLError as GraphQLError4
+} from "graphql";
+function add(a, b) {
+  return Math.min(a + b, Number.MAX_SAFE_INTEGER);
+}
+function countOf(walk, selectionSet) {
+  let total = 0;
+  for (const selection of selectionSet.selections) {
+    if (selection.kind === "Field") {
+      if (walk.ignoreIntrospection && isIntrospectionRoot(selection.name.value))
+        continue;
+      total = add(total, 1);
+      if (selection.selectionSet)
+        total = add(total, countOf(walk, selection.selectionSet));
+    } else if (selection.kind === "InlineFragment") {
+      total = add(total, countOf(walk, selection.selectionSet));
+    } else {
+      total = add(total, fragmentCount(walk, selection.name.value));
+    }
+  }
+  return total;
+}
+function fragmentCount(walk, name) {
+  const known = walk.fragmentCounts.get(name);
+  if (known !== undefined)
+    return known;
+  const fragment = walk.getFragment(name);
+  if (!fragment || walk.counting.has(name))
+    return 0;
+  walk.counting.add(name);
+  const result = countOf(walk, fragment.selectionSet);
+  walk.counting.delete(name);
+  walk.fragmentCounts.set(name, result);
+  return result;
+}
+function maxFields(options) {
+  const limit = options.limit;
+  assertInteger("maxFields: limit", limit, 1);
+  return (context) => {
+    const walk = {
+      getFragment: (name) => context.getFragment(name),
+      fragmentCounts: new Map,
+      counting: new Set,
+      ignoreIntrospection: options.ignoreIntrospection ?? false
+    };
+    return {
+      OperationDefinition(operation) {
+        const fields = countOf(walk, operation.selectionSet);
+        if (fields > limit) {
+          context.reportError(new GraphQLError4(`${operationLabel(operation)} selects ${fields} fields, more than the ${limit} allowed`, {
+            nodes: [operation],
+            extensions: { code: "QUERY_TOO_WIDE", fields, limit }
+          }));
+        }
+        return false;
+      }
+    };
+  };
+}
+// src/limits/max-list-cost.ts
+import {
+  GraphQLError as GraphQLError5,
+  getNamedType,
+  getNullableType,
+  isListType
+} from "graphql";
+
+// src/limits/cost-context.ts
+import {
+  isInterfaceType as isInterfaceType2,
+  isObjectType as isObjectType2
+} from "graphql";
+var CEILING = Number.MAX_SAFE_INTEGER;
+var add2 = (a, b) => Math.min(CEILING, a + b);
+var multiply = (a, b) => Math.min(CEILING, a * b);
+function fieldOf(cost, parent, name) {
+  if (parent === cost.schema.getQueryType() && isIntrospectionRoot(name)) {
+    return introspectionRoot(name);
+  }
+  return isObjectType2(parent) || isInterfaceType2(parent) ? parent.getFields()[name] : undefined;
+}
+function rootType(schema, operation) {
+  const type = operation.operation === "query" ? schema.getQueryType() : operation.operation === "mutation" ? schema.getMutationType() : schema.getSubscriptionType();
+  return type ?? undefined;
+}
+var EXACT_SIZES = 8;
+var NO_PENDING = -1;
+function memoSize(known, pending) {
+  if (pending === undefined || known.has(pending) || known.size < EXACT_SIZES) {
+    return pending;
+  }
+  let rounded = 2 ** Math.ceil(Math.log2(Math.max(pending, 1)));
+  if (rounded < pending)
+    rounded *= 2;
+  return Math.min(CEILING, rounded);
+}
+
+// src/limits/list-size.ts
+import {
+  isAbstractType
+} from "graphql";
+var CEILING2 = Number.MAX_SAFE_INTEGER;
+var CANONICAL_INTEGER = /^(0|[1-9]\d*)$/;
+function sizeOf(value) {
+  if (typeof value === "string") {
+    return CANONICAL_INTEGER.test(value) ? Math.min(Number(value), CEILING2) : undefined;
+  }
+  if (typeof value === "bigint") {
+    return value >= 0n ? Math.min(Number(value), CEILING2) : undefined;
+  }
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? Math.min(value, CEILING2) : undefined;
+}
+function literalSize(value) {
+  if (value.kind === "IntValue" || value.kind === "FloatValue") {
+    return sizeOf(Number(value.value));
+  }
+  return value.kind === "StringValue" ? sizeOf(value.value) : undefined;
+}
+function defaultSizeOf(argument) {
+  if (!argument)
+    return;
+  if ("defaultValue" in argument) {
+    const size = sizeOf(argument.defaultValue);
+    if (size !== undefined)
+      return size;
+  }
+  if (!("default" in argument))
+    return;
+  const fallback = argument.default;
+  if (typeof fallback !== "object" || fallback === null)
+    return;
+  if ("value" in fallback)
+    return sizeOf(fallback.value);
+  if ("literal" in fallback && typeof fallback.literal === "object") {
+    const literal = fallback.literal;
+    return literal !== null && "kind" in literal ? literalSize(literal) : undefined;
+  }
+  return;
+}
+var profiles = new WeakMap;
+function profileOf(cost, parent, definition) {
+  let bySizes = profiles.get(cost.schema);
+  if (!bySizes) {
+    bySizes = new WeakMap;
+    profiles.set(cost.schema, bySizes);
+  }
+  let byField = bySizes.get(cost.sizeArguments);
+  if (!byField) {
+    byField = new Map;
+    bySizes.set(cost.sizeArguments, byField);
+  }
+  const key = `${parent?.name}.${definition.name}`;
+  const known = byField.get(key);
+  if (known)
+    return known;
+  const definitions = [definition];
+  if (isAbstractType(parent)) {
+    for (const type of cost.schema.getPossibleTypes(parent)) {
+      const implemented = type.getFields()[definition.name];
+      if (implemented)
+        definitions.push(implemented);
+    }
+  }
+  const profile = {
+    largest: cost.sizeArguments.map(() => {
+      return;
+    }),
+    someLack: cost.sizeArguments.map(() => false),
+    someBare: false,
+    declares: false,
+    someUndeclared: false
+  };
+  for (const field of definitions) {
+    let any = false;
+    cost.sizeArguments.forEach((name, index) => {
+      const size = defaultSizeOf(field.args.find((arg) => arg.name === name));
+      if (size === undefined) {
+        profile.someLack[index] = true;
+        return;
+      }
+      any = true;
+      profile.largest[index] = Math.max(profile.largest[index] ?? 0, size);
+    });
+    if (!any)
+      profile.someBare = true;
+    if (field.args.some((arg) => cost.sizeArguments.includes(arg.name))) {
+      profile.declares = true;
+    } else {
+      profile.someUndeclared = true;
+    }
+  }
+  byField.set(key, profile);
+  return profile;
+}
+function argumentSize(cost, profile, index, node) {
+  const largest = profile.largest[index];
+  if (!node)
+    return largest;
+  const literal = literalSize(node.value);
+  if (literal !== undefined)
+    return literal;
+  return profile.someLack[index] ? Math.max(largest ?? 0, cost.defaultFirst) : largest;
+}
+function statedSize(cost, parent, definition, args) {
+  const profile = profileOf(cost, parent, definition);
+  let size;
+  let given = false;
+  cost.sizeArguments.forEach((name, index) => {
+    const node = args?.find((arg) => arg.name.value === name);
+    if (node)
+      given = true;
+    const said = argumentSize(cost, profile, index, node);
+    if (said !== undefined)
+      size = Math.max(size ?? 0, said);
+  });
+  if (size !== undefined && !given && profile.someBare) {
+    return Math.max(size, cost.defaultFirst);
+  }
+  return size;
+}
+function declaration(cost, parent, definition) {
+  const { declares, someUndeclared } = profileOf(cost, parent, definition);
+  if (!declares)
+    return "none";
+  return someUndeclared ? "some" : "all";
+}
+
+// src/limits/pending-size.ts
+function listSizeUnder(cost, parent, definition, args, pending) {
+  const own = () => statedSize(cost, parent, definition, args) ?? cost.defaultFirst;
+  if (pending === undefined)
+    return own();
+  const declared = declaration(cost, parent, definition);
+  if (declared === "none")
+    return pending;
+  if (declared === "all")
+    return own();
+  return Math.max(pending, own());
+}
+
+// src/limits/max-list-cost.ts
+var DEFAULT_SIZE_ARGUMENTS = ["first", "last", "limit"];
+function fieldCost(cost, parent, selection, definition, pending) {
+  if (!selection.selectionSet)
+    return 1;
+  const name = selection.name.value;
+  const type = getNamedType(definition.type);
+  if (!isListType(getNullableType(definition.type))) {
+    const stated = statedSize(cost, parent, definition, selection.arguments);
+    const inner = costOf(cost, selection.selectionSet, type, stated);
+    return add2(1, inner);
+  }
+  const inner = costOf(cost, selection.selectionSet, type, undefined);
+  const size = parent?.name.startsWith("__") ? introspectionSize(cost.schema, name) : listSizeUnder(cost, parent, definition, selection.arguments, pending);
+  return add2(1, multiply(inner, size));
+}
+function costOf(cost, selectionSet, parent, pending) {
+  let total = 0;
+  for (const selection of selectionSet.selections) {
+    if (selection.kind === "Field") {
+      const name = selection.name.value;
+      if (name === "__typename")
+        continue;
+      if (isIntrospectionRoot(name) && cost.ignoreIntrospection)
+        continue;
+      const definition = fieldOf(cost, parent, name);
+      if (!definition)
+        continue;
+      total = add2(total, fieldCost(cost, parent, selection, definition, pending));
+    } else if (selection.kind === "InlineFragment") {
+      const condition = selection.typeCondition ? cost.schema.getType(selection.typeCondition.name.value) : parent;
+      total = add2(total, costOf(cost, selection.selectionSet, condition, pending));
+    } else {
+      total = add2(total, fragmentCost(cost, selection.name.value, pending));
+    }
+  }
+  return total;
+}
+function fragmentCost(cost, name, pending) {
+  let known = cost.fragmentCosts.get(name);
+  if (!known) {
+    known = new Map;
+    cost.fragmentCosts.set(name, known);
+  }
+  const size = memoSize(known, pending);
+  const key = size ?? NO_PENDING;
+  const memo = known.get(key);
+  if (memo !== undefined)
+    return memo;
+  const fragment = cost.getFragment(name);
+  if (!fragment || cost.costing.has(name))
+    return 0;
+  cost.costing.add(name);
+  const result = costOf(cost, fragment.selectionSet, cost.schema.getType(fragment.typeCondition.name.value), size);
+  cost.costing.delete(name);
+  known.set(key, result);
+  return result;
+}
+function maxListCost(options) {
+  const { budget, defaultFirst } = options;
+  const sizeArguments = Object.freeze([
+    ...options.sizeArguments ?? DEFAULT_SIZE_ARGUMENTS
+  ]);
+  assertInteger("maxListCost: budget", budget, 0);
+  assertInteger("maxListCost: defaultFirst", defaultFirst, 0);
+  return (context) => {
+    const schema = context.getSchema();
+    const cost = {
+      schema,
+      sizeArguments,
+      defaultFirst,
+      ignoreIntrospection: options.ignoreIntrospection ?? false,
+      getFragment: (name) => context.getFragment(name),
+      fragmentCosts: new Map,
+      costing: new Set
+    };
+    return {
+      OperationDefinition(operation) {
+        const total = costOf(cost, operation.selectionSet, rootType(schema, operation), undefined);
+        if (total > budget) {
+          context.reportError(new GraphQLError5(`${operationLabel(operation)} costs ${total}, more than the ${budget} allowed`, {
+            nodes: [operation],
+            extensions: {
+              code: "QUERY_TOO_COSTLY",
+              cost: total,
+              limit: budget
+            }
+          }));
+        }
+        return false;
+      }
+    };
+  };
+}
 // src/validated.ts
 import { z } from "zod";
 function validated(schema, resolve) {
@@ -145,21 +622,21 @@ import {
 } from "graphql";
 var wrapped = Symbol.for("@nxgt/graphql-validation/wrapped");
 var wrappedWith = Symbol.for("@nxgt/graphql-validation/formats");
-function checking(schema, where, resolve) {
+function checking(schema, where, resolve, constraintOf) {
   const check = async (source, args, context, info) => await resolve(source, await parseArgs(schema, args, where, constraintOf), context, info);
   check[wrapped] = true;
   return check;
 }
-function wrap(field, args, where, subscription) {
+function wrap(field, args, where, subscription, constraintOf) {
   const subscribe = field.subscribe ?? (subscription ? defaultFieldResolver : undefined);
   if (subscribe) {
     if (!subscribe[wrapped])
-      field.subscribe = checking(args, where, subscribe);
+      field.subscribe = checking(args, where, subscribe, constraintOf);
     return;
   }
   const resolve = field.resolve ?? defaultFieldResolver;
   if (!resolve[wrapped])
-    field.resolve = checking(args, where, resolve);
+    field.resolve = checking(args, where, resolve, constraintOf);
 }
 function withValidation(schema, options = {}) {
   const formats = options.formats ?? {};
@@ -168,9 +645,16 @@ function withValidation(schema, options = {}) {
   if (before && !sameFormats(before, formats)) {
     throw new Error("withValidation: this schema is already wrapped with other formats. Call withValidation once, with every format.");
   }
-  const directive = checkConstraints2(schema, (type, field, args) => {
+  const directive = checkConstraints2(schema, (type, field, args, declared) => {
     const subscription = type === schema.getSubscriptionType();
-    wrap(field, args, `${type.name}.${field.name}`, subscription);
+    const named = (issue) => {
+      const argument = constraintOf(issue);
+      if (!argument)
+        return;
+      const found = declared(issue.path).find(({ rule }) => rule.argument === argument);
+      return found && { argument, value: found.value };
+    };
+    wrap(field, args, `${type.name}.${field.name}`, subscription, named);
   }, formats);
   if (!directive) {
     throw new Error("withValidation: this schema declares no @constraint directive. Add constraintTypeDefs to its type definitions.");
@@ -192,9 +676,12 @@ export {
   fieldsError,
   inputPath,
   invalidInputError,
+  maxDepth,
+  maxFields,
+  maxListCost,
   validated,
   withValidation
 };
 
-//# debugId=DE46FB4511D84A4364756E2164756E21
+//# debugId=3B937DADAE820B8964756E2164756E21
 //# sourceMappingURL=index.js.map