@fougere/schema 0.8.2-alpha.0 → 0.8.4-alpha.0

package/src/validator/InputValidator.ts

@@ -2,7 +2,7 @@ import { Boundary } from '../axis/boundary/Boundary.js';
 import { Lifecycle } from '../axis/lifecycle/Lifecycle.js';
 import { Role } from '../axis/role/Role.js';
 import type { Field, Fields } from '../field/Field.js';
-import type { ValidationError, ValidationResult } from '../validation.js';
+import type { ValidationError, ValidationResult } from '../lib/validation.js';
 import { FieldValueValidator } from './FieldValueValidator.js';
 import { InputRefusal } from './InputRefusal.js';
 
@@ -32,7 +32,7 @@ export class InputValidator {
     if (typeof input !== 'object' || input === null) {
       return {
         success: false,
-        errors: [{ path: '.', message: InputRefusal.notAnObject }],
+        errors: [{ path: [], message: InputRefusal.notAnObject }],
       };
     }
 
@@ -42,12 +42,12 @@ export class InputValidator {
 
     for (const key of Object.keys(data)) {
       if (!Object.hasOwn(this.fields, key)) {
-        errors.push({ path: key, message: InputRefusal.unknownField });
+        errors.push({ path: [key], message: InputRefusal.unknownField });
       }
     }
 
     for (const [key, field] of Object.entries(this.fields)) {
-      const path = key;
+      const path = [key];
       const value = data[key];
 
       if (value === undefined) {
@@ -61,8 +61,7 @@ export class InputValidator {
         continue;
       }
 
-      const boundary = Boundary.of(field);
-      if (boundary.readOnly) {
+      if (Boundary.of(field).readOnly) {
         errors.push({ path, message: InputRefusal.readOnly });
         continue;
       }
@@ -71,18 +70,9 @@ export class InputValidator {
         continue;
       }
 
-      const checked = FieldValueValidator.of(field).validate(value);
-      if ('error' in checked) {
-        errors.push({ path, message: checked.error });
-        continue;
-      }
-      if (checked.value === null) {
-        row[key] = null;
-        continue;
-      }
-      const decoded = boundary.decode(checked.value);
-      if ('error' in decoded) errors.push({ path, message: decoded.error });
-      else row[key] = decoded.value;
+      const parsed = FieldValueValidator.of(field).parse(value);
+      if ('error' in parsed) errors.push({ path: [...path, ...parsed.path ?? []], message: parsed.error });
+      else row[key] = parsed.value;
     }
 
     if (errors.length > 0) return { success: false, errors };

package/src/vocabulary/preset/created.ts

@@ -1,11 +1,6 @@
 import { Field } from '../../field/Field.js';
 import { date } from '../primitive/date.js';
 
-/**
- * So a creation stamp is written by the storage and refused from a client.
- * FR : pour qu'un horodatage de création soit écrit par le storage et refusé au client.
- * `created()` → `create: 'now'`, `update: 'forbidden'`
- */
 export function created(): Field<Date> {
   return date().with({
     lifecycle: { create: 'now', update: 'forbidden' },

package/src/vocabulary/preset/email.ts

@@ -1,11 +1,6 @@
 import { text, type TextOptions } from '../primitive/text.js';
 import type { Field } from '../../field/Field.js';
 
-/**
- * So the format is stated once, where everyone would otherwise write the same regex.
- * FR : pour que le format soit énoncé une fois, là où chacun réécrirait la même regex.
- * `email({ max: 254 })`
- */
 export function email(opts?: Omit<TextOptions, 'format'>): Field<string> {
   return text({ ...opts, format: 'email' });
 }

package/src/vocabulary/preset/updated.ts

@@ -1,11 +1,6 @@
 import { created } from './created.js';
 import { Field } from '../../field/Field.js';
 
-/**
- * So the dual of `created()` is re-stamped at every write, by the same hand.
- * FR : pour que le dual de `created()` soit ré-estampé à chaque écriture, par la même main.
- * `updated()` → `create: 'now'`, `update: 'now'`
- */
 export function updated(): Field<Date> {
   const base = created();
   return base.with({ lifecycle: { ...base.lifecycle, update: 'now' } });

package/src/vocabulary/preset/url.ts

@@ -1,11 +1,6 @@
 import { text, type TextOptions } from '../primitive/text.js';
 import type { Field } from '../../field/Field.js';
 
-/**
- * So a URL is a text with a stated format, not a type of its own.
- * FR : pour qu'une URL soit un texte au format énoncé, pas un type à part.
- * `url()` → `{ type: 'string', format: 'uri' }`
- */
 export function url(opts?: Omit<TextOptions, 'format'>): Field<string> {
   return text({ ...opts, format: 'uri' });
 }

package/src/vocabulary/primitive/bool.ts

@@ -1,10 +1,5 @@
 import { Field } from '../../field/Field.js';
 
-/**
- * So a default is a lifecycle rule, not a value the handler remembers to set.
- * FR : pour qu'un défaut soit une règle de cycle de vie, pas un oubli possible du handler.
- * `bool({ default: false })`
- */
 export function bool(opts?: { default?: boolean; description?: string }): Field<boolean> {
   return new Field<boolean>({
     shape: { type: 'boolean' },

package/src/vocabulary/primitive/date.ts

@@ -1,9 +1,9 @@
 import { Field } from '../../field/Field.js';
 
 /**
- * So a date is a string on the wire and a `Date` in a handler, with no word said.
- * FR : pour qu'une date soit une chaîne sur le fil et une `Date` dans un handler.
- * `date()` → `{ type: 'string', format: 'date-time' }`, decoded by the `isoDate` boundary
+ * A `Date` in a handler, an ISO string on the wire — the `isoDate` boundary converts.
+ * FR : un `Date` dans un handler, une chaîne ISO sur le fil — `isoDate` convertit.
+ * `date()` → `{ type: 'string', format: 'date-time' }`
  */
 export function date(): Field<Date> {
   return new Field<Date>({ shape: { type: 'string', format: 'date-time' } });

package/src/vocabulary/primitive/json.ts

@@ -7,9 +7,9 @@ export function json<E extends SchemaView & (new (...args: any[]) => any)>(
   of: E,
 ): Field<InstanceType<E>>;
 /**
- * So a stored object can carry a schema, instead of admitting any shape forever.
- * FR : pour qu'un objet stocké porte un schéma, au lieu d'admettre toute forme à jamais.
- * `json(Address)` → the object's properties and its required keys
+ * `json(Address)` where the object has a shape; `json()` alone admits any shape forever.
+ * FR : `json(Address)` quand l'objet a une forme ; `json()` seul admet tout, à jamais.
+ * `json(Address)` → the entity's properties, and its required keys
  */
 export function json(of?: SchemaView): Field<unknown> {
   if (!of) return new Field({ shape: { type: 'object' } });

package/src/vocabulary/primitive/list.ts

@@ -6,9 +6,9 @@ export interface ListOptions {
 }
 
 /**
- * So a list of values is told apart from a relation, which `many()` declares.
- * FR : pour qu'une liste de valeurs se distingue d'une relation, que `many()` déclare.
- * `list(text(), { max: 5 })`; `list(ref(User))` → throws
+ * A list of VALUES. The other side of a relation is `many()`, and passing one here throws.
+ * FR : une liste de VALEURS. L'autre côté d'une relation est `many()`, et en passer une ici lève.
+ * `list(text(), { max: 5 })` → `{ type: 'array', items: { type: 'string' }, maxItems: 5 }`
  */
 export function list<T>(item: Field<T>, opts?: ListOptions): Field<T[]> {
   if (item.role?.relation)

package/src/vocabulary/primitive/many.ts

@@ -2,9 +2,9 @@ import { Relation, type EntityConstructor } from '../../axis/role/Relation.js';
 import { Field } from '../../field/Field.js';
 
 /**
- * So the other side of a reference is declared, and holds no column.
- * FR : pour que l'autre côté d'une référence soit déclaré, sans porter de colonne.
- * `many(() => Post)` → a collection, absent from the row a client sends
+ * The far side of a `ref()`: no column of its own, and absent from what a client sends.
+ * FR : l'autre côté d'un `ref()` : aucune colonne à lui, et absent de ce qu'un client envoie.
+ * `many(() => Post)` → `{ type: 'array' }` with `role.relation.kind` `'many'`
  */
 export function many<E extends EntityConstructor>(
   target: E | (() => E),

package/src/vocabulary/primitive/number.ts

@@ -8,11 +8,6 @@ export interface NumberOptions {
   description?: string;
 }
 
-/**
- * So `integer` is a shape, not a second word to remember.
- * FR : pour qu'`integer` soit une forme, pas un second mot à retenir.
- * `number({ integer: true, min: 0 })` → `{ type: 'integer', minimum: 0 }`
- */
 export function number(opts?: NumberOptions): Field<number> {
   return new Field<number>({
     shape: {

package/src/vocabulary/primitive/oneOf.ts

@@ -12,9 +12,9 @@ export function oneOf<const T extends readonly string[]>(
   ...args: [...T, OneOfOptions<T[number]>]
 ): Field<T[number]>;
 /**
- * So the set is in the type and in the CHECK constraint, from one declaration.
- * FR : pour que l'ensemble soit dans le type et dans la contrainte CHECK, d'une déclaration.
- * `oneOf('draft', 'published', { default: 'draft' })`
+ * The set travels: GraphQL enum, form `select` and DDL `CHECK`, from this one declaration.
+ * FR : l'ensemble voyage : enum GraphQL, `select` du formulaire, `CHECK` du DDL.
+ * `oneOf('draft', 'published', { default: 'draft' })` → `{ type: 'string', enum: [...] }`
  */
 export function oneOf<const T extends readonly string[]>(
   ...args: [...T] | [...T, OneOfOptions<T[number]>]

package/src/vocabulary/primitive/primary.ts

@@ -8,9 +8,9 @@ interface PrimaryOptions {
 export function primary(opts?: PrimaryOptions): Field<string>;
 export function primary<T>(field: Field<T>): Field<T>;
 /**
- * So an id is generated and write-once by declaring nothing else.
- * FR : pour qu'un identifiant soit généré et écrit une fois sans rien déclarer d'autre.
- * `primary()` → cuid2, `update: 'forbidden'`; `primary(number())` → the same on a number
+ * `primary()` for a generated id; `primary(number())` to make a declared field the key.
+ * FR : `primary()` pour un identifiant généré ; `primary(number())` pour promouvoir un champ.
+ * `primary()` → `create: { generate: 'cuid2' }`, `update: 'forbidden'`
  */
 export function primary(fieldOrOptions?: Field | PrimaryOptions): Field {
   if (Field.is(fieldOrOptions)) {

package/src/vocabulary/primitive/ref.ts

@@ -5,11 +5,6 @@ export interface RefOptions {
   cascade?: boolean;
 }
 
-/**
- * So a reference names the target entity, and the column type follows from it.
- * FR : pour qu'une référence nomme l'entité cible, la colonne en découlant.
- * `ref(() => User, { cascade: true })`
- */
 export function ref<E extends EntityConstructor>(
   target: E | (() => E),
   opts?: RefOptions,

package/src/vocabulary/primitive/text.ts

@@ -10,11 +10,6 @@ export interface TextOptions {
   description?: string;
 }
 
-/**
- * So a string field states its bounds where the DDL and the validator both read them.
- * FR : pour qu'un champ texte énonce ses bornes là où le DDL et le juge les lisent.
- * `text({ max: 200, format: 'email' })`
- */
 export function text(opts?: TextOptions): Field<string> {
   return new Field<string>({
     shape: {

package/src/vocabulary/rule/immutable.ts

@@ -1,11 +1,6 @@
 import { vocabulary } from '../vocabulary.js';
 import { Field } from '../../field/Field.js';
 
-/**
- * So a write-once field is refused on a patch by the validator, not by the table.
- * FR : pour qu'un champ écrit une fois soit refusé par le juge sur une modification.
- * `immutable(text())` → `update: 'forbidden'`
- */
 export const immutable: <T>(field: Field<T>) => Field<T> = vocabulary(
   'immutable',
   () => ({

package/src/vocabulary/rule/indexed.ts

@@ -1,11 +1,6 @@
 import { vocabulary } from '../vocabulary.js';
 import { Field } from '../../field/Field.js';
 
-/**
- * So the entity states the index, and the DDL is the one that emits it.
- * FR : pour que l'entité énonce l'index, le DDL étant celui qui l'émet.
- * `indexed(text())` → `role.index` is `true`
- */
 export const indexed: <T>(field: Field<T>) => Field<T> = vocabulary('indexed', () => ({
   role: { index: true },
 }));

package/src/vocabulary/rule/nullable.ts

@@ -3,9 +3,9 @@ import { Shapes } from '../../axis/shape/Shape.js';
 import { type Field } from '../../field/Field.js';
 
 /**
- * So `null` becomes a legal value, without touching whether the field is required.
- * FR : pour que `null` devienne légal, sans toucher au caractère obligatoire du champ.
- * `nullable(text())` → `{ type: ['string', 'null'] }`, still required at create
+ * Adds `null` and leaves the field REQUIRED — `optional()` is the one permitting absence.
+ * FR : ajoute `null` en laissant le champ OBLIGATOIRE — `optional()` permet l'absence.
+ * `nullable(text())` → `{ type: ['string', 'null'] }`, and `validate({})` still refuses
  */
 export const nullable: <T>(field: Field<T>) => Field<T | null> = vocabulary(
   'nullable',

package/src/vocabulary/rule/optional.ts

@@ -3,9 +3,9 @@ import { Shapes } from '../../axis/shape/Shape.js';
 import { type Field } from '../../field/Field.js';
 
 /**
- * So the two questions are settled at once: `null` is legal, and absence is too.
- * FR : pour que les deux questions soient réglées d'un coup : `null` légal, absence permise.
- * `optional(text())` → nullable shape and `create: 'optional'`
+ * Adds `null` AND permits absence. A field that already states a `create` rule keeps it.
+ * FR : ajoute `null` ET permet l'absence. Un champ qui énonce déjà un `create` le garde.
+ * `optional(text())` → `{ type: ['string', 'null'] }` and `create: 'optional'`
  */
 export const optional: <T>(field: Field<T>) => Field<T | null> = vocabulary(
   'optional',

package/src/vocabulary/rule/readOnly.ts

@@ -3,13 +3,13 @@ import { Boundary } from '../../axis/boundary/Boundary.js';
 import { Field } from '../../field/Field.js';
 
 /**
- * So a field a client may read but never write says so once, on the field.
- * FR : pour qu'un champ lisible mais non écrivable le dise une fois, sur le champ.
- * `readOnly(text())` → `boundary.in` is `'closed'`, absent from every form
+ * Closes the way in, so the field leaves `Visibility.input` and every form derived from it.
+ * FR : ferme l'entrée : le champ quitte `Visibility.input` et tout formulaire qui en dérive.
+ * `readOnly(text())` → `boundary.in` is `'closed'`
  */
 export const readOnly: <T>(field: Field<T>) => Field<T> = vocabulary(
   'readOnly',
   (field) => ({
-    boundary: Boundary.declared(field).with({ in: 'closed' }),
+    boundary: Boundary.declared(field).declaring({ in: 'closed' }),
   }),
 );

package/src/vocabulary/rule/unique.ts

@@ -1,11 +1,6 @@
 import { vocabulary } from '../vocabulary.js';
 import { Field } from '../../field/Field.js';
 
-/**
- * So a field is unique on its own, whatever key it ends up under.
- * FR : pour qu'un champ soit unique à lui seul, quelle que soit sa clé.
- * `unique(email)` → `role.unique` is true
- */
 export const unique: <T>(field: Field<T>) => Field<T> = vocabulary('unique', () => ({
   role: { unique: true },
 }));

package/src/vocabulary/rule/writeOnly.ts

@@ -3,13 +3,13 @@ import { Boundary } from '../../axis/boundary/Boundary.js';
 import { Field } from '../../field/Field.js';
 
 /**
- * So a secret leaves no response, the dual of `readOnly` on the same axis.
- * FR : pour qu'un secret ne reparte dans aucune réponse, dual de `readOnly`.
+ * Closes the way out, the dual of `readOnly`: the value is written and never sent back.
+ * FR : ferme la sortie, dual de `readOnly` : la valeur s'écrit et ne repart jamais.
  * `writeOnly(text())` → `boundary.out` is `'closed'`
  */
 export const writeOnly: <T>(field: Field<T>) => Field<T> = vocabulary(
   'writeOnly',
   (field) => ({
-    boundary: Boundary.declared(field).with({ out: 'closed' }),
+    boundary: Boundary.declared(field).declaring({ out: 'closed' }),
   }),
 );

package/src/vocabulary/vocabulary.ts

@@ -5,8 +5,8 @@ import { dequal } from 'dequal';
 const MEMBER_SLOTS = [...EXTENSION_SLOTS, 'meta'] as const;
 
 /**
- * So a word is one statement about a field, not a rebuilt field.
- * FR : pour qu'un mot soit une affirmation sur un champ, pas un champ reconstruit.
+ * Builds a `rule/` word, which states members on the field it receives.
+ * FR : fabrique un mot de `rule/`, qui énonce des membres sur le champ reçu.
  * `vocabulary('indexed', () => ({ role: { index: true } }))`
  */
 export function vocabulary(
@@ -19,9 +19,9 @@ export function vocabulary(
 export type FieldWord = (field: Field<any>) => Field<any>;
 
 /**
- * So two words that state the same member differently refuse instead of one winning.
- * FR : pour que deux mots contredisant un même membre refusent, plutôt qu'un l'emporte.
- * `readOnly(writeOnly(text()))` → both close a different side, so both apply
+ * Refuses two words stating one member differently, rather than letting the outer win.
+ * FR : refuse deux mots qui énoncent un même membre différemment.
+ * `readOnly(writeOnly(text()))` → both apply; `immutable(created())` → throws
  */
 function merge(name: string, field: Field, given: Partial<Field>): Partial<Field> {
   const merged: Record<string, unknown> = {};

package/dist/validation.d.ts

@@ -1,17 +0,0 @@
-export interface ValidationError {
-    path: string;
-    message: string;
-}
-export type ValidationResult<T> = {
-    success: true;
-    data: T;
-} | {
-    success: false;
-    errors: ValidationError[];
-};
-export type Checked = {
-    value: unknown;
-} | {
-    error: string;
-};
-//# sourceMappingURL=validation.d.ts.map

package/dist/validation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAC1B;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,CAAC,CAAA;CAAE,GAC1B;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,eAAe,EAAE,CAAA;CAAE,CAAC;AAElD,MAAM,MAAM,OAAO,GAAG;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC"}

package/dist/validation.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=validation.js.map

package/dist/validation.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"validation.js","sourceRoot":"","sources":["../src/validation.ts"],"names":[],"mappings":""}

package/src/validation.ts

@@ -1,10 +0,0 @@
-export interface ValidationError {
-  path: string;
-  message: string;
-}
-
-export type ValidationResult<T> =
-  | { success: true; data: T }
-  | { success: false; errors: ValidationError[] };
-
-export type Checked = { value: unknown } | { error: string };