@nxgt/graphql-validation 0.2.0 → 0.3.0

package/README.md

@@ -19,14 +19,14 @@ Peers, all **required**:
 | --- | --- |
 | `graphql` | `^16.11.0 \|\| ^17.0.0` |
 | `zod` | `>=4.6.5 <5` |
-| `typescript` | `^6.0.3` |
+| `typescript` | `^6.0.3 \|\| ^7.0.0` |
 
 Your `tsconfig.json` needs:
 
 ```jsonc
 {
   "compilerOptions": {
-    "moduleResolution": "bundler" // `nodenext` is not supported
+    "moduleResolution": "bundler" // or "nodenext" / "node16", from 0.2.1; "node" / "node10" ignore `exports`
   }
 }
 ```
@@ -83,6 +83,61 @@ request. The resolver receives the parsed arguments.
 Every argument, its rule and its Zod equivalent, and the formats, are in
 [Constraints](docs/guide/constraints.md).
 
+### Your own formats
+
+Name a format of your own in `@constraint(format: "...")`: write each as a Zod
+string schema in one module, and hand the record to `withValidation`.
+
+```ts
+// formats.ts
+import { z } from 'zod';
+
+export const formatSchemas = {
+  siret: z.string().regex(/^\d{14}$/, 'Invalid SIRET: write its 14 digits'),
+  'work-email': z.email().endsWith('@example.com', 'Use your work address'),
+};
+```
+
+```ts
+import { makeExecutableSchema } from '@graphql-tools/schema';
+import { constraintTypeDefs, withValidation } from '@nxgt/graphql-validation';
+import { formatSchemas } from './formats';
+
+const typeDefs = [
+  constraintTypeDefs,
+  /* GraphQL */ `
+    input Company {
+      siret: String! @constraint(format: "siret")
+      contact: String @constraint(format: "work-email", maxLength: 64)
+    }
+    type Mutation { register(input: Company!): Boolean }
+  `,
+];
+const resolvers = { Mutation: { register: () => true } };
+
+export const schema = withValidation(
+  makeExecutableSchema({ typeDefs, resolvers }),
+  { formats: formatSchemas },
+);
+```
+
+A format is `z.string()` or a string format (`z.email()`, …), narrowed as you
+like (`.regex()`, `.refine()`) but never transformed nor rewritten (no
+`.transform()`, `.trim()`, `.toLowerCase()`, `z.url()`, which trims,
+`z.coerce.string()`, …): the resolver receives what the client sent. The one
+exception is the built-in `uri`, `z.url()`, which trims surrounding white
+space (see [Formats](docs/guide/constraints.md#formats)). The other rules
+narrow your format as they narrow a built-in one. Its messages are yours: a
+refusal reads as your schema writes it, and its issue carries
+`constraint: "format"`. A name is lowercase letters, digits and hyphens; a
+built-in name (`email`, …) is a type error and refused at startup, and so is
+a schema that rewrites the value (a custom `.check()` that does fails the
+request, naming the format). An async check (`.refine(async …)`) works in a
+request, and runs once per value. Call `withValidation` once, with every
+format: a second call with the same record wraps nothing; with other
+formats, or none, it throws. Without `formats`, nothing changes. Details in
+[Constraints](docs/guide/constraints.md#your-own-formats).
+
 ### Read the error
 
 ```json
@@ -171,12 +226,13 @@ the directive declared is this package's. Both at once throw
 | Export | Is |
 | --- | --- |
 | `constraintTypeDefs` | the SDL of `@constraint`, to add to `typeDefs` |
-| `withValidation(schema)` | checks every `@constraint` of a schema before its resolvers run |
+| `withValidation(schema, options?)` | checks every `@constraint` of a schema before its resolvers run; `options.formats` adds your own formats |
 | `validated(schema \| shape, resolver)` | a resolver whose arguments a Zod schema checks |
 | `badUserInput(where, zodError)` | builds the error above, for code that validates by hand |
 | `ValidationIssue`, `BadUserInputExtensions` | the types of `extensions.issues` and `extensions` |
 | `ConstraintArgument` | the type of `issues[].constraint`: `'minLength' \| 'format' \| ...` |
 | `ArgsSchema`, `SchemaOf` | the types `validated` accepts |
+| `WithValidationOptions`, `FormatSchemas`, `OwnFormats`, `StringSchema`, `FormatName` | the types of `withValidation`'s options: a record of string schemas, with no built-in format name (`FormatName`) |
 
 `@nxgt/graphql-validation/codegen` is for a code generator, such as
 [`@nxgt/graphql-codegen-zod`](https://www.npmjs.com/package/@nxgt/graphql-codegen-zod): it writes the schemas `withValidation` builds as source, and
@@ -184,9 +240,10 @@ refuses the schemas `withValidation` refuses. A server does not need it.
 
 | Export | Is |
 | --- | --- |
-| `checkConstraints(schema, onArgs?)` | runs every startup check of `withValidation` without wrapping anything; returns the `@constraint` directive, or `undefined` when the schema declares none |
+| `checkConstraints(schema, onArgs?, formats?)` | runs every startup check of `withValidation` without wrapping anything; returns the `@constraint` directive, or `undefined` when the schema declares none. `formats` is the record `withValidation` takes, checked the same way |
 | `constraintsOn(directive, node)` | the `Constraint`s written on an argument or input field (`arg.astNode`), `format` first |
-| `inputCode(type, constraints, where, named, options?)` | the schema of that argument or field as source, `z` a free identifier: built-in scalars and lists written in full, nullable types `.nullish()`; every other named type (enum, input object, custom scalar) is what `named(type)` returns. A constraint that cannot apply throws the startup message, naming `where`. `options` (`InputCodeOptions`): `list({ type, code, single })` returns each list's source, given `code` (the array with every rule) and `single` (the list's named type, non-null, without rules), e.g. to take a single value as graphql does: `single`, wrapped, piped into `code` |
+| `inputCode(type, constraints, where, named, options?, formats?)` | the schema of that argument or field as source, `z` a free identifier: built-in scalars and lists written in full, nullable types `.nullish()`; every other named type (enum, input object, custom scalar) is what `named(type)` returns. A constraint that cannot apply throws the startup message, naming `where`. `options` (`InputCodeOptions`): `list({ type, code, single })` returns each list's source, given `code` (the array with every rule) and `single` (the list's named type, non-null, without rules), e.g. to take a single value as graphql does: `single`, wrapped, piped into `code`. `format(name)` returns the source of one of your formats, since only the generator knows where your record is imported from: a reference to your schema, which the other rules narrow (`formatSchemas.siret.max(14)`); built-in formats never reach it. `formats`: the record `withValidation` takes, checked the same way, so its names are known; a field using one of them without the `format` option throws `@constraint(format: "<name>") is one of the application's formats: its source is the code generator's to write, through inputCode's format option.` |
+| `FormatSchemas` | the type of that record |
 | `Constraint` | `{ rule, value }`, one `@constraint` argument. Of `rule`, read `argument` (`'minItems'`, `'format'`, …), `target` (`'list'` for `minItems`/`maxItems`, else what the rule narrows) and `base` (`true` for `format`, which picks the schema the others narrow); the rest is internal |
 
 ```ts
@@ -233,4 +290,4 @@ Every startup error and its fix is in [Troubleshooting](docs/troubleshooting.md)
 - [Documentation index](docs/README.md)
 - Guides: [Constraints](docs/guide/constraints.md), [Errors](docs/guide/errors.md)
 - [Troubleshooting](docs/troubleshooting.md)
-- [Roadmap](docs/roadmap.md): a Zod codegen plugin, your own formats, schemas that read the context
+- [Roadmap](docs/roadmap.md): your own formats in the Zod codegen plugin, schemas that read the context

package/dist/bad-user-input.d.ts

@@ -1,6 +1,6 @@
 import { GraphQLError } from 'graphql';
 import type { z } from 'zod';
-import type { ConstraintArgument } from './rules';
+import type { ConstraintArgument } from './rules/index.js';
 /** One reason an input was refused, at its path inside the arguments. */
 export interface ValidationIssue {
     /** `['input', 'address', 'zip']`: the argument, then the input fields. */

package/dist/builder/args-schema.d.ts

@@ -1,6 +1,6 @@
 import type { GraphQLField, GraphQLObjectType } from 'graphql';
 import { z } from 'zod';
-import type { InputSchemas } from './input-schema';
+import type { InputSchemas } from './input-schema.js';
 /**
  * The schema of a field's arguments, or `undefined` when none of them can
  * break a constraint, so a field with nothing to check is left untouched.

package/dist/builder/check-constraints.d.ts

@@ -1,5 +1,6 @@
 import { type GraphQLDirective, type GraphQLField, type GraphQLObjectType, type GraphQLSchema } from 'graphql';
 import type { z } from 'zod';
+import { type FormatSchemas } from '../formats/registry.js';
 /**
  * Runs every check `withValidation` makes at startup, so a code generator
  * refuses the same schemas: the declaration is `constraintTypeDefs`', every
@@ -8,8 +9,12 @@ import type { z } from 'zod';
  * default value breaks its own. `onArgs` receives each object field's
  * arguments schema, for a field with something to check.
  *
+ * `formats` are the application's own, which `@constraint(format: "...")`
+ * may name beside the built-in ones; they are checked first (name, no
+ * built-in replaced, a Zod string schema each).
+ *
  * Returns the `@constraint` directive, or `undefined` when the schema
  * declares none (and so carries no constraint).
  */
-export declare function checkConstraints(schema: GraphQLSchema, onArgs?: (type: GraphQLObjectType, field: GraphQLField<unknown, unknown>, args: z.ZodType) => void): GraphQLDirective | undefined;
+export declare function checkConstraints(schema: GraphQLSchema, onArgs?: (type: GraphQLObjectType, field: GraphQLField<unknown, unknown>, args: z.ZodType) => void, formats?: FormatSchemas): GraphQLDirective | undefined;
 //# sourceMappingURL=check-constraints.d.ts.map

package/dist/builder/check-constraints.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"check-constraints.d.ts","sourceRoot":"","sources":["../../src/builder/check-constraints.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,KAAK,gBAAgB,EACrB,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACtB,KAAK,aAAa,EAGlB,MAAM,SAAS,CAAC;AACjB,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAM7B;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAC/B,MAAM,EAAE,aAAa,EACrB,MAAM,CAAC,EAAE,CACR,IAAI,EAAE,iBAAiB,EACvB,KAAK,EAAE,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,EACrC,IAAI,EAAE,CAAC,CAAC,OAAO,KACX,IAAI,GACP,gBAAgB,GAAG,SAAS,CAyB9B"}
+{"version":3,"file":"check-constraints.d.ts","sourceRoot":"","sources":["../../src/builder/check-constraints.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,KAAK,gBAAgB,EACrB,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACtB,KAAK,aAAa,EAGlB,MAAM,SAAS,CAAC;AACjB,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B,OAAO,EAAE,KAAK,aAAa,EAAc,MAAM,qBAAqB,CAAC;AAKrE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAC/B,MAAM,EAAE,aAAa,EACrB,MAAM,CAAC,EAAE,CACR,IAAI,EAAE,iBAAiB,EACvB,KAAK,EAAE,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,EACrC,IAAI,EAAE,CAAC,CAAC,OAAO,KACX,IAAI,EACT,OAAO,CAAC,EAAE,aAAa,GACrB,gBAAgB,GAAG,SAAS,CAyB9B"}

package/dist/builder/constraints.d.ts

@@ -1,5 +1,5 @@
 import { type DirectiveNode, type GraphQLDirective } from 'graphql';
-import { type RegisteredRule } from '../rules';
+import { type RegisteredRule } from '../rules/index.js';
 /** One `@constraint` argument written on an argument or an input field. */
 export interface Constraint {
     readonly rule: RegisteredRule;

package/dist/builder/input-code.d.ts

@@ -1,5 +1,6 @@
 import { type GraphQLInputType, type GraphQLList, type GraphQLNamedInputType } from 'graphql';
-import type { Constraint } from './constraints';
+import { type FormatSchemas } from '../formats/registry.js';
+import type { Constraint } from './constraints.js';
 /**
  * The source of the schema of one argument or input field: what
  * `InputSchemas` builds at startup, written for a code generator. The
@@ -10,8 +11,12 @@ import type { Constraint } from './constraints';
  * object's or an enum's schema by name, a custom scalar's from a mapping.
  * The built-in scalars are written here, with their constraints. A
  * constraint that cannot apply fails as it does at startup.
+ *
+ * `formats` are the application's own, as `withValidation` takes them: a
+ * name among them is a known format, which a built-in one is not. Their
+ * source is `options.format`'s to write.
  */
-export declare function inputCode(type: GraphQLInputType, constraints: readonly Constraint[], where: string, named: (type: GraphQLNamedInputType) => string, options?: InputCodeOptions): string;
+export declare function inputCode(type: GraphQLInputType, constraints: readonly Constraint[], where: string, named: (type: GraphQLNamedInputType) => string, options?: InputCodeOptions, formats?: FormatSchemas): string;
 /** How `inputCode` writes what a generator may want written otherwise. */
 export interface InputCodeOptions {
     /**
@@ -25,5 +30,13 @@ export interface InputCodeOptions {
         readonly code: string;
         readonly single: string;
     }) => string;
+    /**
+     * The source of one of the application's formats, given its name (a key
+     * of the `formats` record): a reference to the application's own schema,
+     * which the rules after `format` narrow (`formatSchemas.slug.max(40)`).
+     * A built-in format is written inline and never reaches it. Without it,
+     * a field using one of the application's formats throws.
+     */
+    readonly format?: (name: string) => string;
 }
 //# sourceMappingURL=input-code.d.ts.map

package/dist/builder/input-code.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"input-code.d.ts","sourceRoot":"","sources":["../../src/builder/input-code.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,KAAK,gBAAgB,EACrB,KAAK,WAAW,EAChB,KAAK,qBAAqB,EAK1B,MAAM,SAAS,CAAC;AAEjB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAGhD;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CACxB,IAAI,EAAE,gBAAgB,EACtB,WAAW,EAAE,SAAS,UAAU,EAAE,EAClC,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,CAAC,IAAI,EAAE,qBAAqB,KAAK,MAAM,EAC9C,OAAO,GAAE,gBAAqB,GAC5B,MAAM,CAGR;AAED,0EAA0E;AAC1E,MAAM,WAAW,gBAAgB;IAChC;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE;QACtB,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC,gBAAgB,CAAC,CAAC;QAC7C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;KACxB,KAAK,MAAM,CAAC;CACb"}
+{"version":3,"file":"input-code.d.ts","sourceRoot":"","sources":["../../src/builder/input-code.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,KAAK,gBAAgB,EACrB,KAAK,WAAW,EAChB,KAAK,qBAAqB,EAK1B,MAAM,SAAS,CAAC;AACjB,OAAO,EAEN,KAAK,aAAa,EAElB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAGhD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CACxB,IAAI,EAAE,gBAAgB,EACtB,WAAW,EAAE,SAAS,UAAU,EAAE,EAClC,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,CAAC,IAAI,EAAE,qBAAqB,KAAK,MAAM,EAC9C,OAAO,GAAE,gBAAqB,EAC9B,OAAO,CAAC,EAAE,aAAa,GACrB,MAAM,CAQR;AAED,0EAA0E;AAC1E,MAAM,WAAW,gBAAgB;IAChC;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE;QACtB,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC,gBAAgB,CAAC,CAAC;QAC7C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;KACxB,KAAK,MAAM,CAAC;IACb;;;;;;OAMG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;CAC3C"}

package/dist/builder/input-schema.d.ts

@@ -1,5 +1,6 @@
 import { type GraphQLArgument, type GraphQLDirective, type GraphQLInputField, type GraphQLInputType, type GraphQLSchema } from 'graphql';
 import { z } from 'zod';
+import { type FormatRegistry } from '../formats/registry.js';
 /**
  * Builds the schemas of the arguments and input fields of one GraphQL
  * schema, once each: an input type is walked a single time however many
@@ -9,7 +10,8 @@ import { z } from 'zod';
 export declare class InputSchemas {
     #private;
     readonly directive: GraphQLDirective | undefined;
-    constructor(schema: GraphQLSchema);
+    /** `formats`: the built-in ones by default, the application's added. */
+    constructor(schema: GraphQLSchema, formats?: FormatRegistry);
     /** Whether a value of this type can break a constraint anywhere inside. */
     isConstrained(type: GraphQLInputType): boolean;
     /**

package/dist/builder/input-schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"input-schema.d.ts","sourceRoot":"","sources":["../../src/builder/input-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAEN,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EAEtB,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAMlB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB;;;;;GAKG;AACH,qBAAa,YAAY;;IACxB,QAAQ,CAAC,SAAS,EAAE,gBAAgB,GAAG,SAAS,CAAC;gBAWrC,MAAM,EAAE,aAAa;IAwBjC,2EAA2E;IAC3E,aAAa,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO;IAK9C;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI;IAMrC,gEAAgE;IAChE,UAAU,CAAC,KAAK,EAAE,eAAe,GAAG,iBAAiB,GAAG,OAAO;IAO/D,8EAA8E;IAC9E,EAAE,CAAC,KAAK,EAAE,eAAe,GAAG,iBAAiB,EAAE,KAAK,EAAE,MAAM,GAAG,CAAC,CAAC,OAAO;IAYxE;;;;OAIG;IACH,aAAa,IAAI,IAAI;CAoErB"}
+{"version":3,"file":"input-schema.d.ts","sourceRoot":"","sources":["../../src/builder/input-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAEN,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EAEtB,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAMlB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,KAAK,cAAc,EAAc,MAAM,qBAAqB,CAAC;AAMtE;;;;;GAKG;AACH,qBAAa,YAAY;;IACxB,QAAQ,CAAC,SAAS,EAAE,gBAAgB,GAAG,SAAS,CAAC;IAYjD,wEAAwE;gBAC5D,MAAM,EAAE,aAAa,EAAE,OAAO,GAAE,cAA6B;IAyBzE,2EAA2E;IAC3E,aAAa,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO;IAK9C;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI;IAMrC,gEAAgE;IAChE,UAAU,CAAC,KAAK,EAAE,eAAe,GAAG,iBAAiB,GAAG,OAAO;IAO/D,8EAA8E;IAC9E,EAAE,CAAC,KAAK,EAAE,eAAe,GAAG,iBAAiB,EAAE,KAAK,EAAE,MAAM,GAAG,CAAC,CAAC,OAAO;IAYxE;;;;OAIG;IACH,aAAa,IAAI,IAAI;CA+ErB"}

package/dist/builder/leaf.d.ts

@@ -1,7 +1,7 @@
 import { type GraphQLLeafType } from 'graphql';
 import { z } from 'zod';
-import type { Target } from '../rules/rule';
-import type { Constraint } from './constraints';
+import type { RuleContext, Target } from '../rules/rule.js';
+import type { Constraint } from './constraints.js';
 /**
  * Fails unless every constraint applies to a value of `type`: `minLength` on
  * an `Int`, anything on a custom scalar or an enum, fails, naming `where`.
@@ -16,7 +16,7 @@ export declare function assertObjectTargets(typeName: string, constraints: reado
  * without any is left as graphql parsed it. A constraint that cannot apply
  * fails here, at startup.
  */
-export declare function leafSchema(type: GraphQLLeafType, constraints: readonly Constraint[], where: string): z.ZodType;
+export declare function leafSchema(type: GraphQLLeafType, constraints: readonly Constraint[], where: string, context: RuleContext): z.ZodType;
 /** The source of a built-in scalar's schema, before its constraints. */
 export declare function baseCode(type: GraphQLLeafType): string | undefined;
 /** What a rule's target reads as in an error. */

package/dist/builder/leaf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"leaf.d.ts","sourceRoot":"","sources":["../../src/builder/leaf.ts"],"names":[],"mappings":"AAAA,OAAO,EAKN,KAAK,eAAe,EAEpB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAehD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAChC,IAAI,EAAE,eAAe,EACrB,WAAW,EAAE,SAAS,UAAU,EAAE,EAClC,KAAK,EAAE,MAAM,GACX,IAAI,CAMN;AAED,2EAA2E;AAC3E,wBAAgB,mBAAmB,CAClC,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,SAAS,UAAU,EAAE,EAClC,KAAK,EAAE,MAAM,GACX,IAAI,CAIN;AAYD;;;;GAIG;AACH,wBAAgB,UAAU,CACzB,IAAI,EAAE,eAAe,EACrB,WAAW,EAAE,SAAS,UAAU,EAAE,EAClC,KAAK,EAAE,MAAM,GACX,CAAC,CAAC,OAAO,CAQX;AAED,wEAAwE;AACxE,wBAAgB,QAAQ,CAAC,IAAI,EAAE,eAAe,GAAG,MAAM,GAAG,SAAS,CAMlE;AAED,iDAAiD;AACjD,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAIrD"}
+{"version":3,"file":"leaf.d.ts","sourceRoot":"","sources":["../../src/builder/leaf.ts"],"names":[],"mappings":"AAAA,OAAO,EAKN,KAAK,eAAe,EAEpB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAehD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAChC,IAAI,EAAE,eAAe,EACrB,WAAW,EAAE,SAAS,UAAU,EAAE,EAClC,KAAK,EAAE,MAAM,GACX,IAAI,CAMN;AAED,2EAA2E;AAC3E,wBAAgB,mBAAmB,CAClC,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,SAAS,UAAU,EAAE,EAClC,KAAK,EAAE,MAAM,GACX,IAAI,CAIN;AAYD;;;;GAIG;AACH,wBAAgB,UAAU,CACzB,IAAI,EAAE,eAAe,EACrB,WAAW,EAAE,SAAS,UAAU,EAAE,EAClC,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,WAAW,GAClB,CAAC,CAAC,OAAO,CAQX;AAED,wEAAwE;AACxE,wBAAgB,QAAQ,CAAC,IAAI,EAAE,eAAe,GAAG,MAAM,GAAG,SAAS,CAMlE;AAED,iDAAiD;AACjD,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAIrD"}

package/dist/chunks/{index-s1kkmg35.js → index-1mzzydy3.js}

@@ -1,8 +1,10 @@
 import {
+  __export,
+  RULE_PARAM,
   rules,
   applyRule,
   assertOwnConstraint
-} from "./index-rbxe5m3y.js";
+} from "./index-xcaf9kes.js";
 
 // src/builder/constraints.ts
 import {
@@ -24,12 +26,196 @@ import {
   isObjectType
 } from "graphql";
 
-// src/builder/args-schema.ts
+// src/formats/registry.ts
+import { z as z9 } from "zod";
+
+// 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]));
+
+// src/formats/registry.ts
+var NAME = /^[a-z][a-z0-9-]*$/;
+
+class FormatRegistry {
+  #formats = new Map;
+  #async;
+  constructor(own = {}) {
+    for (const format of Object.values(formats))
+      this.#formats.set(format.name, format);
+    for (const [name, schema] of Object.entries(own)) {
+      if (!NAME.test(name)) {
+        throw new Error(`Invalid format name ${JSON.stringify(name)}: write it in lowercase letters, digits and hyphens, starting with a letter.`);
+      }
+      if (this.#formats.has(name)) {
+        throw new Error(`The format "${name}" is built in: give yours another name.`);
+      }
+      if (!isStringSchema(schema)) {
+        throw new Error(`The format "${name}" is not a Zod string schema: write z.string() or a string format such as z.email(), narrowed with .regex() or .refine(), never transformed.`);
+      }
+      if (!runnable(schema)) {
+        throw new Error(`The format "${name}" cannot be run: its definition reads type: 'string' but it has no _zod.run, so it was not built by zod 4. Pass the schema z.string() or a string format returns, not an object shaped like one.`);
+      }
+      if (rewrites(schema)) {
+        throw new Error(`The format "${name}" rewrites the value (.trim(), .toLowerCase(), .toUpperCase(), .normalize(), .slugify(), .overwrite(), z.url(), z.httpUrl() or z.coerce.string()): refuse what is not canonical with .regex() or .refine() instead, so the server and the client check the value as it was sent.`);
+      }
+      const own = marked(name, schema, () => {
+        this.#async = name;
+      });
+      this.#formats.set(name, { name, toZod: () => own });
+    }
+  }
+  named(name) {
+    const format = this.#formats.get(name);
+    if (format)
+      return format;
+    throw new Error(`Unknown @constraint format "${name}". Known formats: ${[...this.#formats.keys()].join(", ")}.`);
+  }
+  takeAsync() {
+    const name = this.#async;
+    this.#async = undefined;
+    return name;
+  }
+}
+function isStringSchema(value) {
+  return definition(value)?.type === "string";
+}
+function runnable(schema) {
+  return typeof schema?._zod?.run === "function";
+}
+function rewrites(schema) {
+  const def = definition(schema);
+  if (def?.coerce || def?.format === "url")
+    return true;
+  return (def?.checks ?? []).some((check) => {
+    const own = definition(check);
+    return own?.check === "overwrite" || own?.format === "url";
+  });
+}
+function definition(value) {
+  return value?._zod?.def;
+}
+function marked(name, schema, onAsync) {
+  return z9.string().superRefine((value, ctx) => {
+    const raise = (result) => {
+      if (result.issues.length === 0 && result.value !== value) {
+        throw new Error(`The format "${name}" rewrote the value it checked: a format checks the value and never changes it, so the server and the client check the value as it was sent. Refuse what is not canonical with .regex() or .refine() instead of setting payload.value in a .check().`);
+      }
+      for (const raw of result.issues) {
+        const issue = z9.core.util.finalizeIssue(raw, RUN, z9.core.config());
+        const params = "params" in issue ? issue.params : undefined;
+        ctx.addIssue({
+          ...issue,
+          params: { ...params, [RULE_PARAM]: "format" },
+          ...raw.continue === false && { continue: false }
+        });
+      }
+    };
+    const result = schema._zod.run({ value, issues: [] }, RUN);
+    if (!(result instanceof Promise)) {
+      raise(result);
+      return;
+    }
+    const pending = result.then(raise);
+    pending.catch(() => {});
+    onAsync();
+    return pending;
+  });
+}
+var RUN = { async: true };
+var builtInRegistry = new FormatRegistry;
+var registries = new WeakMap;
+function registryOf(own) {
+  if (!own)
+    return builtInRegistry;
+  let registry = registries.get(own);
+  if (!registry) {
+    registry = new FormatRegistry(own);
+    registries.set(own, registry);
+  }
+  return registry;
+}
+
+// src/builder/args-schema.ts
+import { z as z10 } 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) => [
+  return z10.object(Object.fromEntries(field.args.map((arg) => [
     arg.name,
     inputs.of(arg, `${parent}.${field.name}(${arg.name}:)`)
   ])));
@@ -65,7 +251,7 @@ import {
   isNonNullType,
   valueFromAST
 } from "graphql";
-import { z as z3 } from "zod";
+import { z as z12 } from "zod";
 
 // src/builder/leaf.ts
 import {
@@ -75,7 +261,7 @@ import {
   GraphQLInt,
   GraphQLString
 } from "graphql";
-import { z as z2 } from "zod";
+import { z as z11 } from "zod";
 var kinds = {
   [GraphQLString.name]: "string",
   [GraphQLID.name]: "string",
@@ -84,8 +270,8 @@ var kinds = {
 };
 function baseOf(type) {
   if (type.name === GraphQLInt.name)
-    return z2.number().int();
-  return kinds[type.name] === "number" ? z2.number() : z2.string();
+    return z11.number().int();
+  return kinds[type.name] === "number" ? z11.number() : z11.string();
 }
 function assertLeafTargets(type, constraints, where) {
   const misplaced = constraints.find(({ rule }) => rule.target === "list");
@@ -104,13 +290,13 @@ function assertObjectTargets(typeName, constraints, where) {
 function misplacedOn({ rule }, where, typeName) {
   return new Error(`@constraint(${rule.argument}) on ${where} needs ${describeTarget(rule.target)}, not ${typeName}.`);
 }
-function leafSchema(type, constraints, where) {
+function leafSchema(type, constraints, where, context) {
   if (constraints.length === 0)
-    return z2.unknown();
+    return z11.unknown();
   assertLeafTargets(type, constraints, where);
   let schema = baseOf(type);
   for (const { rule, value } of constraints) {
-    schema = applyRule(rule, schema, value);
+    schema = applyRule(rule, schema, value, context);
   }
   return schema;
 }
@@ -134,10 +320,12 @@ function describeTarget(target) {
 // src/builder/input-schema.ts
 class InputSchemas {
   directive;
+  #context;
   #objects = new Map;
   #defaults = [];
   #constrained = new Set;
-  constructor(schema) {
+  constructor(schema, formats = registryOf()) {
+    this.#context = { formats };
     this.directive = schema.getDirective("constraint") ?? undefined;
     const objects = Object.values(schema.getTypeMap()).filter(isInputObjectType);
     for (let changed = true;changed; ) {
@@ -178,7 +366,15 @@ class InputSchemas {
       const value = valueFromAST(literal, type);
       if (value === undefined)
         continue;
-      const result = schema.safeParse(value);
+      let result;
+      try {
+        result = schema.safeParse(value);
+      } catch (error) {
+        if (!(error instanceof z12.core.$ZodAsyncError))
+          throw error;
+        const format = this.#context.formats.takeAsync();
+        throw new Error(`The default value of ${where} cannot be checked at startup: ${format ? `the format "${format}"` : "its format"} checks asynchronously, and a default value is checked synchronously. Drop the default, or move the async check out of the format into validated().`);
+      }
       if (!result.success) {
         throw new Error(`The default value of ${where} breaks its @constraint: ${result.error.issues[0]?.message}`);
       }
@@ -195,26 +391,26 @@ class InputSchemas {
     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));
+      let list = z12.array(this.#typed(type.ofType, items, where));
       for (const { rule, value } of own)
-        list = applyRule(rule, list, value);
+        list = applyRule(rule, list, value, this.#context);
       return list;
     }
     if (isInputObjectType(type)) {
       assertObjectTargets(type.name, constraints, where);
       return this.#object(type);
     }
-    return leafSchema(type, constraints, where);
+    return leafSchema(type, constraints, where, this.#context);
   }
   #object(type) {
     if (!this.isConstrained(type))
-      return z3.unknown();
+      return z12.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) => [
+    this.#objects.set(type.name, z12.lazy(() => schema));
+    schema = z12.object(Object.fromEntries(Object.values(type.getFields()).map((field) => [
       field.name,
       this.of(field, `${type.name}.${field.name}`)
     ])));
@@ -224,8 +420,8 @@ class InputSchemas {
 }
 
 // src/builder/check-constraints.ts
-function checkConstraints2(schema, onArgs) {
-  const inputs = new InputSchemas(schema);
+function checkConstraints2(schema, onArgs, formats) {
+  const inputs = new InputSchemas(schema, registryOf(formats));
   if (!inputs.directive)
     return;
   assertOwnConstraint(inputs.directive);
@@ -260,7 +456,7 @@ function assertNoDirectiveArgumentConstrained(inputs, schema) {
   }
 }
 
-export { constraintsOn2, assertLeafTargets, assertObjectTargets, baseCode, checkConstraints2 };
+export { registryOf, constraintsOn2, assertLeafTargets, assertObjectTargets, baseCode, checkConstraints2 };
 
-//# debugId=7C317F3D691975BE64756E2164756E21
-//# sourceMappingURL=index-s1kkmg35.js.map
+//# debugId=3026B70F7346E03264756E2164756E21
+//# sourceMappingURL=index-1mzzydy3.js.map