@nxgt/graphql-validation 0.0.0-stage → 0.2.0

package/dist/chunks/index-rbxe5m3y.js

@@ -0,0 +1,319 @@
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/constraint-directive.ts
+import { DirectiveLocation } from "graphql";
+
+// src/rules/all.ts
+var exports_all2 = {};
+__export(exports_all2, {
+  containsRule: () => containsRule,
+  endsWithRule: () => endsWithRule,
+  exclusiveMaxRule: () => exclusiveMaxRule,
+  exclusiveMinRule: () => exclusiveMinRule,
+  formatRule: () => formatRule,
+  maxItemsRule: () => maxItemsRule,
+  maxLengthRule: () => maxLengthRule,
+  maxRule: () => maxRule,
+  minItemsRule: () => minItemsRule,
+  minLengthRule: () => minLengthRule,
+  minRule: () => minRule,
+  multipleOfRule: () => multipleOfRule,
+  notContainsRule: () => notContainsRule,
+  patternRule: () => patternRule,
+  startsWithRule: () => startsWithRule
+});
+
+// src/rules/rule.ts
+function defineRule(rule) {
+  return rule;
+}
+var literal = (value) => JSON.stringify(value);
+
+// src/rules/contains.ts
+var containsRule = defineRule({
+  argument: "contains",
+  type: "String",
+  target: "string",
+  toZod: (schema, value) => schema.includes(value),
+  toCode: (schema, value) => `${schema}.includes(${literal(value)})`,
+  owns: (issue) => issue.format === "includes"
+});
+// src/rules/ends-with.ts
+var endsWithRule = defineRule({
+  argument: "endsWith",
+  type: "String",
+  target: "string",
+  toZod: (schema, value) => schema.endsWith(value),
+  toCode: (schema, value) => `${schema}.endsWith(${literal(value)})`,
+  owns: (issue) => issue.format === "ends_with"
+});
+// src/rules/exclusive-max.ts
+var exclusiveMaxRule = defineRule({
+  argument: "exclusiveMax",
+  type: "Float",
+  target: "number",
+  toZod: (schema, value) => schema.lt(value),
+  toCode: (schema, value) => `${schema}.lt(${value})`,
+  owns: (issue) => issue.code === "too_big" && issue.origin === "number" && issue.inclusive === false
+});
+// src/rules/exclusive-min.ts
+var exclusiveMinRule = defineRule({
+  argument: "exclusiveMin",
+  type: "Float",
+  target: "number",
+  toZod: (schema, value) => schema.gt(value),
+  toCode: (schema, value) => `${schema}.gt(${value})`,
+  owns: (issue) => issue.code === "too_small" && issue.origin === "number" && issue.inclusive === false
+});
+// src/formats/all.ts
+var exports_all = {};
+__export(exports_all, {
+  byteFormat: () => byteFormat,
+  dateFormat: () => dateFormat,
+  dateTimeFormat: () => dateTimeFormat,
+  emailFormat: () => emailFormat,
+  ipv4Format: () => ipv4Format,
+  ipv6Format: () => ipv6Format,
+  uriFormat: () => uriFormat,
+  uuidFormat: () => uuidFormat
+});
+
+// src/formats/byte.ts
+import { z } from "zod";
+
+// src/formats/format.ts
+function defineFormat(format) {
+  return format;
+}
+
+// src/formats/byte.ts
+var byteFormat = defineFormat({
+  name: "byte",
+  toZod: () => z.base64(),
+  toCode: () => "z.base64()"
+});
+// src/formats/date.ts
+import { z as z2 } from "zod";
+var dateFormat = defineFormat({
+  name: "date",
+  toZod: () => z2.iso.date(),
+  toCode: () => "z.iso.date()"
+});
+// src/formats/date-time.ts
+import { z as z3 } from "zod";
+var dateTimeFormat = defineFormat({
+  name: "date-time",
+  toZod: () => z3.iso.datetime({ offset: true }),
+  toCode: () => "z.iso.datetime({ offset: true })"
+});
+// src/formats/email.ts
+import { z as z4 } from "zod";
+var emailFormat = defineFormat({
+  name: "email",
+  toZod: () => z4.email(),
+  toCode: () => "z.email()"
+});
+// src/formats/ipv4.ts
+import { z as z5 } from "zod";
+var ipv4Format = defineFormat({
+  name: "ipv4",
+  toZod: () => z5.ipv4(),
+  toCode: () => "z.ipv4()"
+});
+// src/formats/ipv6.ts
+import { z as z6 } from "zod";
+var ipv6Format = defineFormat({
+  name: "ipv6",
+  toZod: () => z6.ipv6(),
+  toCode: () => "z.ipv6()"
+});
+// src/formats/uri.ts
+import { z as z7 } from "zod";
+var uriFormat = defineFormat({
+  name: "uri",
+  toZod: () => z7.url({ protocol: /^(https?|ftp)$/ }),
+  toCode: () => "z.url({ protocol: /^(https?|ftp)$/ })"
+});
+// src/formats/uuid.ts
+import { z as z8 } from "zod";
+var uuidFormat = defineFormat({
+  name: "uuid",
+  toZod: () => z8.uuid(),
+  toCode: () => "z.uuid()"
+});
+// src/formats/index.ts
+var formats = Object.fromEntries(Object.values(exports_all).map((format) => [format.name, format]));
+function formatNamed(name) {
+  if (Object.hasOwn(formats, name))
+    return formats[name];
+  throw new Error(`Unknown @constraint format "${name}". Known formats: ${Object.keys(formats).join(", ")}.`);
+}
+
+// src/rules/format.ts
+var NARROWING = new Set(["starts_with", "ends_with", "includes", "regex"]);
+var formatRule = defineRule({
+  argument: "format",
+  type: "String",
+  target: "string",
+  base: true,
+  toZod: (_schema, value) => formatNamed(value).toZod(),
+  toCode: (_schema, value) => formatNamed(value).toCode(),
+  owns: (issue) => issue.code === "invalid_format" && !NARROWING.has(issue.format ?? "")
+});
+// src/rules/max.ts
+var maxRule = defineRule({
+  argument: "max",
+  type: "Float",
+  target: "number",
+  toZod: (schema, value) => schema.lte(value),
+  toCode: (schema, value) => `${schema}.lte(${value})`,
+  owns: (issue) => issue.code === "too_big" && issue.origin === "number" && issue.inclusive === true
+});
+// src/rules/max-items.ts
+var maxItemsRule = defineRule({
+  argument: "maxItems",
+  type: "Int",
+  target: "list",
+  toZod: (schema, value) => schema.max(value),
+  toCode: (schema, value) => `${schema}.max(${value})`,
+  owns: (issue) => issue.code === "too_big" && issue.origin === "array"
+});
+// src/rules/max-length.ts
+var maxLengthRule = defineRule({
+  argument: "maxLength",
+  type: "Int",
+  target: "string",
+  toZod: (schema, value) => schema.max(value),
+  toCode: (schema, value) => `${schema}.max(${value})`,
+  owns: (issue) => issue.code === "too_big" && issue.origin === "string"
+});
+// src/rules/min.ts
+var minRule = defineRule({
+  argument: "min",
+  type: "Float",
+  target: "number",
+  toZod: (schema, value) => schema.gte(value),
+  toCode: (schema, value) => `${schema}.gte(${value})`,
+  owns: (issue) => issue.code === "too_small" && issue.origin === "number" && issue.inclusive === true
+});
+// src/rules/min-items.ts
+var minItemsRule = defineRule({
+  argument: "minItems",
+  type: "Int",
+  target: "list",
+  toZod: (schema, value) => schema.min(value),
+  toCode: (schema, value) => `${schema}.min(${value})`,
+  owns: (issue) => issue.code === "too_small" && issue.origin === "array"
+});
+// src/rules/min-length.ts
+var minLengthRule = defineRule({
+  argument: "minLength",
+  type: "Int",
+  target: "string",
+  toZod: (schema, value) => schema.min(value),
+  toCode: (schema, value) => `${schema}.min(${value})`,
+  owns: (issue) => issue.code === "too_small" && issue.origin === "string"
+});
+// src/rules/multiple-of.ts
+var multipleOfRule = defineRule({
+  argument: "multipleOf",
+  type: "Float",
+  target: "number",
+  toZod: (schema, value) => schema.multipleOf(value),
+  toCode: (schema, value) => `${schema}.multipleOf(${value})`,
+  owns: (issue) => issue.code === "not_multiple_of"
+});
+// src/rules/not-contains.ts
+var message = (value) => `Must not contain ${literal(value)}`;
+var notContainsRule = defineRule({
+  argument: "notContains",
+  type: "String",
+  target: "string",
+  toZod: (schema, value) => schema.refine((input) => !input.includes(value), message(value)),
+  toCode: (schema, value) => `${schema}.refine((input) => !input.includes(${literal(value)}), ${literal(message(value))})`,
+  owns: (issue) => issue.code === "custom"
+});
+// src/rules/pattern.ts
+function compile(value) {
+  try {
+    return new RegExp(value);
+  } catch (error) {
+    throw new Error(`Invalid @constraint pattern ${literal(value)}: ${error.message}`);
+  }
+}
+var patternRule = defineRule({
+  argument: "pattern",
+  type: "String",
+  target: "string",
+  toZod: (schema, value) => schema.regex(compile(value)),
+  toCode: (schema, value) => `${schema}.regex(new RegExp(${literal(compile(value).source)}))`,
+  owns: (issue) => issue.format === "regex"
+});
+// src/rules/starts-with.ts
+var startsWithRule = defineRule({
+  argument: "startsWith",
+  type: "String",
+  target: "string",
+  toZod: (schema, value) => schema.startsWith(value),
+  toCode: (schema, value) => `${schema}.startsWith(${literal(value)})`,
+  owns: (issue) => issue.format === "starts_with"
+});
+// src/rules/index.ts
+var rules = Object.fromEntries(Object.values(exports_all2).map((rule) => [rule.argument, rule]));
+function applyRule(rule, schema, value) {
+  const toZod = rule.toZod;
+  return toZod(schema, value);
+}
+function applyRuleCode(rule, source, value) {
+  const toCode = rule.toCode;
+  return toCode(source, value);
+}
+function constraintOf(issue) {
+  const fields = issue;
+  return Object.values(rules).find((rule) => rule.owns(fields))?.argument;
+}
+
+// src/constraint-directive.ts
+var constraintTypeDefs2 = `directive @constraint(
+${Object.values(rules).map((rule) => `	${rule.argument}: ${rule.type}`).join(`
+`)}
+) on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION
+`;
+var allowed = new Set([
+  DirectiveLocation.ARGUMENT_DEFINITION,
+  DirectiveLocation.INPUT_FIELD_DEFINITION
+]);
+function assertOwnConstraint(directive) {
+  const problems = [
+    ...directive.isRepeatable ? ["repeatable, and only its first use is read"] : [],
+    ...directive.locations.filter((location) => !allowed.has(location)).map((location) => `allowed on ${location}`),
+    ...directive.args.flatMap((arg) => {
+      const rule = rules[arg.name];
+      if (!rule)
+        return [`declares ${arg.name}, which no rule reads`];
+      const type = String(arg.type);
+      return type === rule.type ? [] : [`declares ${arg.name}: ${type}, not ${rule.type}`];
+    })
+  ];
+  if (problems.length > 0) {
+    throw new Error(`This schema's @constraint is not constraintTypeDefs': it is ${problems.join("; ")}. Declare it with constraintTypeDefs.`);
+  }
+}
+
+export { rules, applyRule, applyRuleCode, constraintOf, constraintTypeDefs2, assertOwnConstraint };
+
+//# debugId=0FAF783CE1246B6764756E2164756E21
+//# sourceMappingURL=index-rbxe5m3y.js.map

package/dist/chunks/index-rbxe5m3y.js.map

@@ -0,0 +1,37 @@
+{
+  "version": 3,
+  "sources": ["../src/constraint-directive.ts", "../src/rules/rule.ts", "../src/rules/contains.ts", "../src/rules/ends-with.ts", "../src/rules/exclusive-max.ts", "../src/rules/exclusive-min.ts", "../src/formats/byte.ts", "../src/formats/format.ts", "../src/formats/date.ts", "../src/formats/date-time.ts", "../src/formats/email.ts", "../src/formats/ipv4.ts", "../src/formats/ipv6.ts", "../src/formats/uri.ts", "../src/formats/uuid.ts", "../src/formats/index.ts", "../src/rules/format.ts", "../src/rules/max.ts", "../src/rules/max-items.ts", "../src/rules/max-length.ts", "../src/rules/min.ts", "../src/rules/min-items.ts", "../src/rules/min-length.ts", "../src/rules/multiple-of.ts", "../src/rules/not-contains.ts", "../src/rules/pattern.ts", "../src/rules/starts-with.ts", "../src/rules/index.ts"],
+  "sourcesContent": [
+    "import { DirectiveLocation, type GraphQLDirective } from 'graphql';\nimport { rules } from './rules';\n\n/**\n * The SDL of `@constraint`, to add to a schema-first server's `typeDefs`,\n * written from the rules: an argument is declared once its rule exists.\n *\n * Its arguments are graphql-constraint-directive's, minus `uniqueTypeName`\n * (a detail of that package's scalar wrapping). It is allowed on arguments\n * and input fields only, where that package also allows output fields: a\n * resolver's result is the output scalars' job, and a directive that checked\n * nothing there would be a promise broken in silence.\n */\nexport const constraintTypeDefs: string = `directive @constraint(\n${Object.values(rules)\n\t.map((rule) => `\\t${rule.argument}: ${rule.type}`)\n\t.join('\\n')}\n) on ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION\n`;\n\nconst allowed = new Set<string>([\n\tDirectiveLocation.ARGUMENT_DEFINITION,\n\tDirectiveLocation.INPUT_FIELD_DEFINITION,\n]);\n\n/**\n * Fails when the schema's `@constraint` is not the one\n * {@link constraintTypeDefs} declares — graphql-constraint-directive's, say,\n * kept from a migration. Its extra locations would be accepted and checked\n * by nothing, its extra arguments mean nothing here, and an argument of\n * another type would reach a rule as the wrong kind of value.\n */\nexport function assertOwnConstraint(directive: GraphQLDirective): void {\n\tconst problems = [\n\t\t...(directive.isRepeatable\n\t\t\t? ['repeatable, and only its first use is read']\n\t\t\t: []),\n\t\t...directive.locations\n\t\t\t.filter((location) => !allowed.has(location))\n\t\t\t.map((location) => `allowed on ${location}`),\n\t\t...directive.args.flatMap((arg) => {\n\t\t\tconst rule = (rules as Record<string, { type: string } | undefined>)[\n\t\t\t\targ.name\n\t\t\t];\n\t\t\tif (!rule) return [`declares ${arg.name}, which no rule reads`];\n\t\t\tconst type = String(arg.type);\n\t\t\treturn type === rule.type\n\t\t\t\t? []\n\t\t\t\t: [`declares ${arg.name}: ${type}, not ${rule.type}`];\n\t\t}),\n\t];\n\tif (problems.length > 0) {\n\t\tthrow new Error(\n\t\t\t`This schema's @constraint is not constraintTypeDefs': it is ${problems.join('; ')}. Declare it with constraintTypeDefs.`,\n\t\t);\n\t}\n}\n",
+    "import type { z } from 'zod';\nimport type { StringSchema } from '../formats/format';\n\n/** The schema each kind of rule narrows. */\nexport interface Targets {\n\tstring: StringSchema;\n\tnumber: z.ZodNumber;\n\tlist: z.ZodArray<z.ZodType>;\n}\n\nexport type Target = keyof Targets;\n\n/** What a `@constraint` argument's value can be. */\ninterface ValueOf {\n\tInt: number;\n\tFloat: number;\n\tString: string;\n}\n\n/**\n * One `@constraint` argument: its GraphQL type in the directive's SDL, the\n * kind of value it narrows, and the same narrowing twice — `toZod` applied to\n * a schema at startup, `toCode` written as source by a code generator. The\n * spec beside each rule proves the two accept and refuse the same values.\n *\n * A `base` rule (only `format`) replaces the schema instead of narrowing it,\n * so a builder applies it before every other rule of its target.\n */\nexport interface Rule<\n\tA extends string = string,\n\tT extends keyof ValueOf = keyof ValueOf,\n\tK extends Target = Target,\n> {\n\treadonly argument: A;\n\treadonly type: T;\n\treadonly target: K;\n\treadonly base?: true;\n\treadonly toZod: (schema: Targets[K], value: ValueOf[T]) => Targets[K];\n\t/**\n\t * `schema` is the source of the schema this rule narrows. The source names\n\t * zod as a free `z`: the generated file imports it.\n\t */\n\treadonly toCode: (schema: string, value: ValueOf[T]) => string;\n\t/**\n\t * Whether a Zod issue is this rule's refusal, so the error a client gets\n\t * names the rule (`constraint: 'minLength'`), which does not change with\n\t * Zod's own issue codes.\n\t */\n\treadonly owns: (issue: IssueFields) => boolean;\n}\n\n/** The fields of a Zod issue a rule recognises its refusal by. */\nexport interface IssueFields {\n\treadonly code: string;\n\treadonly origin?: string;\n\treadonly format?: string;\n\treadonly inclusive?: boolean;\n}\n\n/** Declares a rule, with its argument name kept literal. */\nexport function defineRule<\n\tconst A extends string,\n\tT extends keyof ValueOf,\n\tK extends Target,\n>(rule: Rule<A, T, K>): Rule<A, T, K> {\n\treturn rule;\n}\n\n/** A string literal as source: quotes and escapes included. */\nexport const literal = (value: string): string => JSON.stringify(value);\n",
+    "import { defineRule, literal } from './rule';\n\nexport const containsRule = defineRule({\n\targument: 'contains',\n\ttype: 'String',\n\ttarget: 'string',\n\ttoZod: (schema, value) => schema.includes(value),\n\ttoCode: (schema, value) => `${schema}.includes(${literal(value)})`,\n\towns: (issue) => issue.format === 'includes',\n});\n",
+    "import { defineRule, literal } from './rule';\n\nexport const endsWithRule = defineRule({\n\targument: 'endsWith',\n\ttype: 'String',\n\ttarget: 'string',\n\ttoZod: (schema, value) => schema.endsWith(value),\n\ttoCode: (schema, value) => `${schema}.endsWith(${literal(value)})`,\n\towns: (issue) => issue.format === 'ends_with',\n});\n",
+    "import { defineRule } from './rule';\n\nexport const exclusiveMaxRule = defineRule({\n\targument: 'exclusiveMax',\n\ttype: 'Float',\n\ttarget: 'number',\n\ttoZod: (schema, value) => schema.lt(value),\n\ttoCode: (schema, value) => `${schema}.lt(${value})`,\n\towns: (issue) =>\n\t\tissue.code === 'too_big' &&\n\t\tissue.origin === 'number' &&\n\t\tissue.inclusive === false,\n});\n",
+    "import { defineRule } from './rule';\n\nexport const exclusiveMinRule = defineRule({\n\targument: 'exclusiveMin',\n\ttype: 'Float',\n\ttarget: 'number',\n\ttoZod: (schema, value) => schema.gt(value),\n\ttoCode: (schema, value) => `${schema}.gt(${value})`,\n\towns: (issue) =>\n\t\tissue.code === 'too_small' &&\n\t\tissue.origin === 'number' &&\n\t\tissue.inclusive === false,\n});\n",
+    "import { z } from 'zod';\nimport { defineFormat } from './format';\n\nexport const byteFormat = defineFormat({\n\tname: 'byte',\n\ttoZod: () => z.base64(),\n\ttoCode: () => 'z.base64()',\n});\n",
+    "import type { z } from 'zod';\n\n/** A string schema, plain or a format (`z.email()` is not a `z.ZodString`). */\nexport type StringSchema = z.ZodString | z.ZodStringFormat;\n\n/**\n * One value of `@constraint(format: \"...\")`: the schema it stands for, as a\n * schema at startup and as source for a code generator.\n */\nexport interface Format<N extends string = string> {\n\treadonly name: N;\n\treadonly toZod: () => StringSchema;\n\treadonly toCode: () => string;\n}\n\n/** Declares a format, with its name kept literal. */\nexport function defineFormat<const N extends string>(\n\tformat: Format<N>,\n): Format<N> {\n\treturn format;\n}\n",
+    "import { z } from 'zod';\nimport { defineFormat } from './format';\n\nexport const dateFormat = defineFormat({\n\tname: 'date',\n\ttoZod: () => z.iso.date(),\n\ttoCode: () => 'z.iso.date()',\n});\n",
+    "import { z } from 'zod';\nimport { defineFormat } from './format';\n\n// RFC 3339 with an offset, in its canonical spelling only: an uppercase `T`\n// and `Z`, seconds present. graphql-constraint-directive (validator's\n// isRFC3339) also takes a lowercase `t`, `z` or a space.\nexport const dateTimeFormat = defineFormat({\n\tname: 'date-time',\n\ttoZod: () => z.iso.datetime({ offset: true }),\n\ttoCode: () => 'z.iso.datetime({ offset: true })',\n});\n",
+    "import { z } from 'zod';\nimport { defineFormat } from './format';\n\nexport const emailFormat = defineFormat({\n\tname: 'email',\n\ttoZod: () => z.email(),\n\ttoCode: () => 'z.email()',\n});\n",
+    "import { z } from 'zod';\nimport { defineFormat } from './format';\n\nexport const ipv4Format = defineFormat({\n\tname: 'ipv4',\n\ttoZod: () => z.ipv4(),\n\ttoCode: () => 'z.ipv4()',\n});\n",
+    "import { z } from 'zod';\nimport { defineFormat } from './format';\n\nexport const ipv6Format = defineFormat({\n\tname: 'ipv6',\n\ttoZod: () => z.ipv6(),\n\ttoCode: () => 'z.ipv6()',\n});\n",
+    "import { z } from 'zod';\nimport { defineFormat } from './format';\n\n// graphql-constraint-directive's `uri` is validator's isURL: http, https or\n// ftp. The scheme is required here, where isURL lets `example.com` through,\n// and nothing else gets in: no `javascript:`, no `mailto:`.\nexport const uriFormat = defineFormat({\n\tname: 'uri',\n\ttoZod: () => z.url({ protocol: /^(https?|ftp)$/ }),\n\ttoCode: () => 'z.url({ protocol: /^(https?|ftp)$/ })',\n});\n",
+    "import { z } from 'zod';\nimport { defineFormat } from './format';\n\nexport const uuidFormat = defineFormat({\n\tname: 'uuid',\n\ttoZod: () => z.uuid(),\n\ttoCode: () => 'z.uuid()',\n});\n",
+    "import * as all from './all';\nimport type { Format } from './format';\n\n/**\n * Every format, keyed by the value `@constraint(format: \"...\")` takes.\n * Derived from what `./all` exports, so a new format is one file and one\n * line there.\n */\nexport const formats = Object.fromEntries(\n\tObject.values(all).map((format) => [format.name, format]),\n) as { readonly [N in FormatName]: Format<N> };\n\n/** A value `@constraint(format: \"...\")` takes. */\nexport type FormatName = (typeof all)[keyof typeof all]['name'];\n\n/** The format named `name`, or an error that lists the known ones. */\nexport function formatNamed(name: string): Format {\n\tif (Object.hasOwn(formats, name)) return formats[name as FormatName];\n\tthrow new Error(\n\t\t`Unknown @constraint format \"${name}\". Known formats: ${Object.keys(formats).join(', ')}.`,\n\t);\n}\n",
+    "import { formatNamed } from '../formats';\nimport { defineRule } from './rule';\n\n// The string rules' own formats; every other invalid_format is a format's.\nconst NARROWING = new Set(['starts_with', 'ends_with', 'includes', 'regex']);\n\nexport const formatRule = defineRule({\n\targument: 'format',\n\ttype: 'String',\n\ttarget: 'string',\n\tbase: true,\n\ttoZod: (_schema, value) => formatNamed(value).toZod(),\n\ttoCode: (_schema, value) => formatNamed(value).toCode(),\n\towns: (issue) =>\n\t\tissue.code === 'invalid_format' && !NARROWING.has(issue.format ?? ''),\n});\n",
+    "import { defineRule } from './rule';\n\nexport const maxRule = defineRule({\n\targument: 'max',\n\ttype: 'Float',\n\ttarget: 'number',\n\ttoZod: (schema, value) => schema.lte(value),\n\ttoCode: (schema, value) => `${schema}.lte(${value})`,\n\towns: (issue) =>\n\t\tissue.code === 'too_big' &&\n\t\tissue.origin === 'number' &&\n\t\tissue.inclusive === true,\n});\n",
+    "import { defineRule } from './rule';\n\nexport const maxItemsRule = defineRule({\n\targument: 'maxItems',\n\ttype: 'Int',\n\ttarget: 'list',\n\ttoZod: (schema, value) => schema.max(value),\n\ttoCode: (schema, value) => `${schema}.max(${value})`,\n\towns: (issue) => issue.code === 'too_big' && issue.origin === 'array',\n});\n",
+    "import { defineRule } from './rule';\n\nexport const maxLengthRule = defineRule({\n\targument: 'maxLength',\n\ttype: 'Int',\n\ttarget: 'string',\n\ttoZod: (schema, value) => schema.max(value),\n\ttoCode: (schema, value) => `${schema}.max(${value})`,\n\towns: (issue) => issue.code === 'too_big' && issue.origin === 'string',\n});\n",
+    "import { defineRule } from './rule';\n\nexport const minRule = defineRule({\n\targument: 'min',\n\ttype: 'Float',\n\ttarget: 'number',\n\ttoZod: (schema, value) => schema.gte(value),\n\ttoCode: (schema, value) => `${schema}.gte(${value})`,\n\towns: (issue) =>\n\t\tissue.code === 'too_small' &&\n\t\tissue.origin === 'number' &&\n\t\tissue.inclusive === true,\n});\n",
+    "import { defineRule } from './rule';\n\nexport const minItemsRule = defineRule({\n\targument: 'minItems',\n\ttype: 'Int',\n\ttarget: 'list',\n\ttoZod: (schema, value) => schema.min(value),\n\ttoCode: (schema, value) => `${schema}.min(${value})`,\n\towns: (issue) => issue.code === 'too_small' && issue.origin === 'array',\n});\n",
+    "import { defineRule } from './rule';\n\nexport const minLengthRule = defineRule({\n\targument: 'minLength',\n\ttype: 'Int',\n\ttarget: 'string',\n\ttoZod: (schema, value) => schema.min(value),\n\ttoCode: (schema, value) => `${schema}.min(${value})`,\n\towns: (issue) => issue.code === 'too_small' && issue.origin === 'string',\n});\n",
+    "import { defineRule } from './rule';\n\nexport const multipleOfRule = defineRule({\n\targument: 'multipleOf',\n\ttype: 'Float',\n\ttarget: 'number',\n\ttoZod: (schema, value) => schema.multipleOf(value),\n\ttoCode: (schema, value) => `${schema}.multipleOf(${value})`,\n\towns: (issue) => issue.code === 'not_multiple_of',\n});\n",
+    "import { defineRule, literal } from './rule';\n\nconst message = (value: string) => `Must not contain ${literal(value)}`;\n\nexport const notContainsRule = defineRule({\n\targument: 'notContains',\n\ttype: 'String',\n\ttarget: 'string',\n\t// `refine` keeps the schema's own type, so later rules still chain.\n\ttoZod: (schema, value) =>\n\t\tschema.refine((input) => !input.includes(value), message(value)),\n\ttoCode: (schema, value) =>\n\t\t`${schema}.refine((input) => !input.includes(${literal(value)}), ${literal(message(value))})`,\n\towns: (issue) => issue.code === 'custom',\n});\n",
+    "import { defineRule, literal } from './rule';\n\n/** The pattern as a RegExp, or an error that names the argument. */\nfunction compile(value: string): RegExp {\n\ttry {\n\t\treturn new RegExp(value);\n\t} catch (error) {\n\t\tthrow new Error(\n\t\t\t`Invalid @constraint pattern ${literal(value)}: ${(error as Error).message}`,\n\t\t);\n\t}\n}\n\nexport const patternRule = defineRule({\n\targument: 'pattern',\n\ttype: 'String',\n\ttarget: 'string',\n\ttoZod: (schema, value) => schema.regex(compile(value)),\n\ttoCode: (schema, value) =>\n\t\t`${schema}.regex(new RegExp(${literal(compile(value).source)}))`,\n\towns: (issue) => issue.format === 'regex',\n});\n",
+    "import { defineRule, literal } from './rule';\n\nexport const startsWithRule = defineRule({\n\targument: 'startsWith',\n\ttype: 'String',\n\ttarget: 'string',\n\ttoZod: (schema, value) => schema.startsWith(value),\n\ttoCode: (schema, value) => `${schema}.startsWith(${literal(value)})`,\n\towns: (issue) => issue.format === 'starts_with',\n});\n",
+    "import type { z } from 'zod';\nimport * as all from './all';\nimport type { IssueFields } from './rule';\n\n/**\n * One of the rules, as its own type: a builder narrows it on `target`, so a\n * number schema never reaches a string rule.\n */\nexport type RegisteredRule = (typeof all)[keyof typeof all];\n\n/** An argument `@constraint` takes. */\nexport type ConstraintArgument = RegisteredRule['argument'];\n\n/**\n * Every rule, keyed by its `@constraint` argument. Derived from what\n * `./all` exports, so a new rule is one file and one line there, and the\n * directive's SDL follows.\n */\nexport const rules = Object.fromEntries(\n\tObject.values(all).map((rule) => [rule.argument, rule]),\n) as {\n\treadonly [A in ConstraintArgument]: Extract<RegisteredRule, { argument: A }>;\n};\n\n/**\n * Applies a rule to a schema its caller has already matched to the rule's\n * target: the one place the rule's typed `toZod` meets a schema built from\n * GraphQL types, which the compiler cannot relate.\n */\nexport function applyRule(\n\trule: RegisteredRule,\n\tschema: z.ZodType,\n\tvalue: string | number,\n): z.ZodType {\n\tconst toZod = rule.toZod as unknown as (\n\t\tschema: z.ZodType,\n\t\tvalue: string | number,\n\t) => z.ZodType;\n\treturn toZod(schema, value);\n}\n\n/** `applyRule` for source: the rule's typed `toCode` on a schema's source. */\nexport function applyRuleCode(\n\trule: RegisteredRule,\n\tsource: string,\n\tvalue: string | number,\n): string {\n\tconst toCode = rule.toCode as (\n\t\tschema: string,\n\t\tvalue: string | number,\n\t) => string;\n\treturn toCode(source, value);\n}\n\n/** The `@constraint` argument whose rule refused with this issue, if any. */\nexport function constraintOf(\n\tissue: z.core.$ZodIssue,\n): ConstraintArgument | undefined {\n\tconst fields = issue as unknown as IssueFields;\n\treturn Object.values(rules).find((rule) => rule.owns(fields))?.argument;\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "0FAF783CE1246B6764756E2164756E21",
+  "names": []
+}

package/dist/chunks/index-s1kkmg35.js

@@ -0,0 +1,266 @@
+import {
+  rules,
+  applyRule,
+  assertOwnConstraint
+} from "./index-rbxe5m3y.js";
+
+// src/builder/constraints.ts
+import {
+  getDirectiveValues
+} from "graphql";
+function constraintsOn2(directive, node) {
+  if (!directive || !node)
+    return [];
+  const values = getDirectiveValues(directive, { directives: node.directives ?? [] }) ?? {};
+  return Object.entries(values).filter(([, value]) => value !== undefined && value !== null).map(([argument, value]) => ({
+    rule: rules[argument],
+    value
+  })).sort((a, b) => Number(Boolean(b.rule.base)) - Number(Boolean(a.rule.base)));
+}
+
+// src/builder/check-constraints.ts
+import {
+  isInterfaceType,
+  isObjectType
+} from "graphql";
+
+// src/builder/args-schema.ts
+import { z } from "zod";
+function argsSchemaOf(inputs, parent, field) {
+  if (!field.args.some((arg) => inputs.needsCheck(arg)))
+    return;
+  return z.object(Object.fromEntries(field.args.map((arg) => [
+    arg.name,
+    inputs.of(arg, `${parent}.${field.name}(${arg.name}:)`)
+  ])));
+}
+function signature(inputs, arg) {
+  return constraintsOn2(inputs.directive, arg.astNode).map(({ rule, value }) => `${rule.argument}: ${JSON.stringify(value)}`).sort().join(", ");
+}
+var written = (signature) => signature ? `@constraint(${signature})` : "no @constraint";
+function assertInterfaceConstraintsKept(inputs, type) {
+  for (const contract of type.getInterfaces()) {
+    for (const [name, declared] of Object.entries(contract.getFields())) {
+      const field = type.getFields()[name];
+      for (const arg of declared.args) {
+        const wanted = signature(inputs, arg);
+        if (!wanted)
+          continue;
+        const own = field?.args.find(({ name: argName }) => argName === arg.name);
+        const found = own ? signature(inputs, own) : wanted;
+        if (found !== wanted) {
+          const verb = found ? "differs on" : "is not repeated on";
+          throw new Error(`@constraint on ${contract.name}.${name}(${arg.name}:) ${verb} ${type.name}.${name}(${arg.name}:), which resolves it (${written(wanted)} there, ${written(found)} here). Write the same @constraint on both.`);
+        }
+      }
+    }
+  }
+}
+
+// src/builder/input-schema.ts
+import {
+  getNamedType,
+  isInputObjectType,
+  isListType,
+  isNonNullType,
+  valueFromAST
+} from "graphql";
+import { z as z3 } from "zod";
+
+// src/builder/leaf.ts
+import {
+  GraphQLBoolean,
+  GraphQLFloat,
+  GraphQLID,
+  GraphQLInt,
+  GraphQLString
+} from "graphql";
+import { z as z2 } from "zod";
+var kinds = {
+  [GraphQLString.name]: "string",
+  [GraphQLID.name]: "string",
+  [GraphQLInt.name]: "number",
+  [GraphQLFloat.name]: "number"
+};
+function baseOf(type) {
+  if (type.name === GraphQLInt.name)
+    return z2.number().int();
+  return kinds[type.name] === "number" ? z2.number() : z2.string();
+}
+function assertLeafTargets(type, constraints, where) {
+  const misplaced = constraints.find(({ rule }) => rule.target === "list");
+  if (misplaced)
+    throw misplacedOn(misplaced, where, type.name);
+  const kind = kinds[type.name];
+  const wrong = constraints.find(({ rule }) => rule.target !== kind);
+  if (wrong)
+    throw misplacedOn(wrong, where, type.name);
+}
+function assertObjectTargets(typeName, constraints, where) {
+  const first = constraints.find(({ rule }) => rule.target === "list") ?? constraints[0];
+  if (first)
+    throw misplacedOn(first, where, typeName);
+}
+function misplacedOn({ rule }, where, typeName) {
+  return new Error(`@constraint(${rule.argument}) on ${where} needs ${describeTarget(rule.target)}, not ${typeName}.`);
+}
+function leafSchema(type, constraints, where) {
+  if (constraints.length === 0)
+    return z2.unknown();
+  assertLeafTargets(type, constraints, where);
+  let schema = baseOf(type);
+  for (const { rule, value } of constraints) {
+    schema = applyRule(rule, schema, value);
+  }
+  return schema;
+}
+function baseCode(type) {
+  if (type.name === GraphQLInt.name)
+    return "z.int32()";
+  if (type.name === GraphQLFloat.name)
+    return "z.number()";
+  if (type.name === GraphQLBoolean.name)
+    return "z.boolean()";
+  return kinds[type.name] === "string" ? "z.string()" : undefined;
+}
+function describeTarget(target) {
+  if (target === "string")
+    return "a String or an ID";
+  if (target === "number")
+    return "an Int or a Float";
+  return "a list";
+}
+
+// src/builder/input-schema.ts
+class InputSchemas {
+  directive;
+  #objects = new Map;
+  #defaults = [];
+  #constrained = new Set;
+  constructor(schema) {
+    this.directive = schema.getDirective("constraint") ?? undefined;
+    const objects = Object.values(schema.getTypeMap()).filter(isInputObjectType);
+    for (let changed = true;changed; ) {
+      changed = false;
+      for (const type of objects) {
+        if (this.#constrained.has(type.name))
+          continue;
+        const constrained = Object.values(type.getFields()).some((field) => constraintsOn2(this.directive, field.astNode).length > 0 || this.isConstrained(field.type));
+        if (constrained) {
+          this.#constrained.add(type.name);
+          changed = true;
+        }
+      }
+    }
+  }
+  isConstrained(type) {
+    const named = getNamedType(type);
+    return isInputObjectType(named) && this.#constrained.has(named.name);
+  }
+  buildAll(schema) {
+    for (const type of Object.values(schema.getTypeMap())) {
+      if (isInputObjectType(type))
+        this.#object(type);
+    }
+  }
+  needsCheck(input) {
+    return constraintsOn2(this.directive, input.astNode).length > 0 || this.isConstrained(input.type);
+  }
+  of(input, where) {
+    const schema = this.#typed(input.type, constraintsOn2(this.directive, input.astNode), where);
+    const literal = input.astNode?.defaultValue;
+    if (literal)
+      this.#defaults.push({ schema, literal, type: input.type, where });
+    return schema;
+  }
+  checkDefaults() {
+    for (const { schema, literal, type, where } of this.#defaults.splice(0)) {
+      const value = valueFromAST(literal, type);
+      if (value === undefined)
+        continue;
+      const result = schema.safeParse(value);
+      if (!result.success) {
+        throw new Error(`The default value of ${where} breaks its @constraint: ${result.error.issues[0]?.message}`);
+      }
+    }
+  }
+  #typed(type, constraints, where) {
+    if (isNonNullType(type))
+      return this.#required(type.ofType, constraints, where);
+    return this.#required(type, constraints, where).nullish();
+  }
+  #required(type, constraints, where) {
+    if (isNonNullType(type))
+      return this.#required(type.ofType, constraints, where);
+    if (isListType(type)) {
+      const own = constraints.filter(({ rule }) => rule.target === "list");
+      const items = constraints.filter(({ rule }) => rule.target !== "list");
+      let list = z3.array(this.#typed(type.ofType, items, where));
+      for (const { rule, value } of own)
+        list = applyRule(rule, list, value);
+      return list;
+    }
+    if (isInputObjectType(type)) {
+      assertObjectTargets(type.name, constraints, where);
+      return this.#object(type);
+    }
+    return leafSchema(type, constraints, where);
+  }
+  #object(type) {
+    if (!this.isConstrained(type))
+      return z3.unknown();
+    const built = this.#objects.get(type.name);
+    if (built)
+      return built;
+    let schema;
+    this.#objects.set(type.name, z3.lazy(() => schema));
+    schema = z3.object(Object.fromEntries(Object.values(type.getFields()).map((field) => [
+      field.name,
+      this.of(field, `${type.name}.${field.name}`)
+    ])));
+    this.#objects.set(type.name, schema);
+    return schema;
+  }
+}
+
+// src/builder/check-constraints.ts
+function checkConstraints2(schema, onArgs) {
+  const inputs = new InputSchemas(schema);
+  if (!inputs.directive)
+    return;
+  assertOwnConstraint(inputs.directive);
+  inputs.buildAll(schema);
+  assertNoDirectiveArgumentConstrained(inputs, schema);
+  for (const type of Object.values(schema.getTypeMap())) {
+    if (type.name.startsWith("__"))
+      continue;
+    if (isInterfaceType(type)) {
+      for (const field of Object.values(type.getFields()))
+        argsSchemaOf(inputs, type.name, field);
+    }
+    if (!isObjectType(type))
+      continue;
+    assertInterfaceConstraintsKept(inputs, type);
+    for (const field of Object.values(type.getFields())) {
+      const args = argsSchemaOf(inputs, type.name, field);
+      if (args)
+        onArgs?.(type, field, args);
+    }
+  }
+  inputs.checkDefaults();
+  return inputs.directive;
+}
+function assertNoDirectiveArgumentConstrained(inputs, schema) {
+  for (const directive of schema.getDirectives()) {
+    for (const arg of directive.args) {
+      if (constraintsOn2(inputs.directive, arg.astNode).length > 0) {
+        throw new Error(`@constraint on @${directive.name}(${arg.name}:) checks nothing: a directive's argument reaches no resolver. Remove it.`);
+      }
+    }
+  }
+}
+
+export { constraintsOn2, assertLeafTargets, assertObjectTargets, baseCode, checkConstraints2 };
+
+//# debugId=7C317F3D691975BE64756E2164756E21
+//# sourceMappingURL=index-s1kkmg35.js.map