@fougere/schema 0.11.0-alpha.0 → 0.12.1-alpha.0

package/src/axis/role/RoleAxis.ts

@@ -1,104 +0,0 @@
-import type { Axis } from '../Axis.js';
-import type { Resolver } from '../Resolver.js';
-import { refuse, oneOfTokens } from '../../projection/card/admission.js';
-import { isObject, lowerFirst, shown } from '../../lib/utils.js';
-import type { ValidationError } from '../../lib/ValidationError.js';
-import { type EntityConstructor } from './EntityConstructor.js';
-import { ON_DELETE, RELATION_KINDS, type Relation } from './Relation.js';
-import { type RoleRules } from './RoleRules.js';
-import type { RoleDescriptor } from '../../projection/card/RoleDescriptor.js';
-
-export const roleAxis: Axis<RoleRules, RoleDescriptor> = {
-  slot: 'role',
-
-  validator(value, errors) {
-    if (!isObject(value)) {
-      errors.push({ path: ['role'], message: `Expected an object — got ${shown(value)}` });
-      return;
-    }
-    for (const flag of ['primary', 'index', 'unique'] as const) {
-      if (value[flag] !== undefined && typeof value[flag] !== 'boolean') {
-        errors.push({
-          path: ['role', flag],
-          message: `Expected a boolean — got ${shown(value[flag])}`,
-        });
-      }
-    }
-    if (value.relation !== undefined) validateRelation(value.relation, errors);
-  },
-
-  /** A card carries the target's NAME: a class cannot cross a process boundary. */
-  describe(role, key) {
-    const descriptor: Mutable<RoleDescriptor> = {};
-    if (role.primary) descriptor.primary = true;
-    if (role.unique) descriptor.unique = [[key]];
-    if (role.index) descriptor.index = true;
-    if (role.relation) {
-      const target = role.relation.to() as { name?: string };
-      descriptor.relation = {
-        to: lowerFirst(target.name ?? ''),
-        kind: role.relation.kind,
-        ...(role.relation.onDelete ? { onDelete: role.relation.onDelete } : {}),
-      };
-    }
-    return Object.keys(descriptor).length ? descriptor : undefined;
-  },
-
-  reconstruct(wire, resolve?: Resolver) {
-    const rules: RoleRules = {};
-    if (wire.primary) rules.primary = true;
-    if (wire.unique?.some((group) => group.length === 1)) rules.unique = true;
-    if (wire.index) rules.index = true;
-    if (wire.relation) {
-      // `validator` cannot serve here: it demands `() => Post` where a card carries a name.
-      if (!oneOfTokens(wire.relation.kind, RELATION_KINDS)) {
-        refuse(
-          `role.relation.kind is ${JSON.stringify(wire.relation.kind)}`,
-          `Expected one of ${RELATION_KINDS.join(', ')}.`,
-        );
-      }
-      if (wire.relation.onDelete !== undefined && !oneOfTokens(wire.relation.onDelete, ON_DELETE)) {
-        refuse(
-          `role.relation.onDelete is ${JSON.stringify(wire.relation.onDelete)}`,
-          `Expected one of ${ON_DELETE.join(', ')}.`,
-        );
-      }
-      const name = wire.relation.to;
-      rules.relation = {
-        to: () => (resolve?.(name) ?? ({ name } as unknown)) as EntityConstructor,
-        kind: wire.relation.kind as Relation['kind'],
-        ...(wire.relation.onDelete ? { onDelete: wire.relation.onDelete as Relation['onDelete'] } : {}),
-      } as RoleRules['relation'];
-    }
-    return rules;
-  },
-};
-
-/**
- * Judges a relation where `to` is a thunk; a card states a NAME, resolved by `toSchema` first.
- * FR : juge une relation dont `to` est une fonction ; une carte y met un NOM, résolu avant.
- * `{ to: User, kind: 'one' }` → `Expected a function returning the target entity, … () => Post`
- */
-function validateRelation(relation: unknown, errors: ValidationError[]): void {
-  if (!isObject(relation)) {
-    errors.push({ path: ['role', 'relation'], message: `Expected an object — got ${shown(relation)}` });
-    return;
-  }
-  if (!oneOfTokens(relation.kind, RELATION_KINDS)) {
-    errors.push({
-      path: ['role', 'relation', 'kind'],
-      message: `Expected 'one' or 'many' — got ${shown(relation.kind)}`,
-    });
-  }
-  if (typeof relation.to !== 'function') {
-    errors.push({ path: ['role', 'relation', 'to'], message: 'Expected a function returning the target entity, such as () => Post' });
-  }
-  if (relation.onDelete !== undefined && !oneOfTokens(relation.onDelete, ON_DELETE)) {
-    errors.push({
-      path: ['role', 'relation', 'onDelete'],
-      message: `Expected 'cascade', 'restrict' or 'set null' — got ${shown(relation.onDelete)}`,
-    });
-  }
-}
-
-type Mutable<T> = { -readonly [K in keyof T]: T[K] };

package/src/axis/role/RoleRules.ts

@@ -1,8 +0,0 @@
-import type { Relation } from './Relation.js';
-
-export interface RoleRules {
-  primary?: boolean;
-  index?: boolean;
-  unique?: boolean;
-  relation?: Relation;
-}

package/src/lib/Checked.ts

@@ -1,5 +0,0 @@
-/**
- * A field's verdict. `path` is where INSIDE the value the refusal happened — empty when the
- * field itself is refused, `['street']` when the shape below it is.
- */
-export type Checked = { value: unknown } | { error: string; path?: readonly string[] };

package/src/projection/card/RelationDescriptor.ts

@@ -1,3 +0,0 @@
-import type { Relation } from '../../axis/role/Relation.js';
-
-export type RelationDescriptor = Pick<Relation, 'kind' | 'onDelete'> & { to: string };

package/src/projection/standard.ts

@@ -1,13 +0,0 @@
-/**
- * The Standard Schema interface, from the package that owns it.
- *
- * This file used to CARRY the spec — 47 lines of hand-copied interface — and the copy had
- * silently fallen a version behind: v1.1 gave `Props` a base it extends (`StandardTypedV1`)
- * and gave `validate` a second `options` parameter. Nothing broke, because a realization may
- * ignore an optional argument, which is exactly why nobody noticed. A standard is owned by
- * whoever publishes it; the package is types only (`index.js` is zero bytes), so importing
- * it costs a browser nothing.
- *
- * Documented: [Standard Schema](https://fougere.dev/docs/schema/standard-schema).
- */
-export type { StandardSchemaV1 } from '@standard-schema/spec';

package/src/validator/AdapterFieldValidator.ts

@@ -1,40 +0,0 @@
-import { Validator } from '@cfworker/json-schema';
-import type { Shape } from '../axis/shape/Shape.js';
-import { isObject } from '../lib/utils.js';
-
-/**
- * The format is DATA, not a TypeScript interface: an interface is erased before a JS
- * caller, a config or a card from another language could be measured against it.
- */
-export class AdapterFieldValidator {
-  private constructor(private readonly validator: Validator) {}
-
-  /** Compiled once, at the adapter's own module load. */
-  static of(format: Shape): AdapterFieldValidator {
-    return new AdapterFieldValidator(new Validator(format as object, '2020-12', true));
-  }
-
-  /** `Post.adapters.sql.body.columnType: Property "postgre" does not match …` */
-  assert(entries: unknown, path: string): void {
-    if (entries === undefined) return;
-
-    if (!isObject(entries)) {
-      throw new Error(
-        `${path}: expected an object keyed by field name, got ${typeof entries}.`,
-      );
-    }
-
-    for (const [field, entry] of Object.entries(entries)) {
-      const verdict = this.validator.validate(entry);
-      if (verdict.valid) continue;
-
-      // The engine reports outermost first and ends on `False boolean schema`, which names
-      // nothing. The last unit above that one is the one carrying the offending key.
-      const units = verdict.errors.filter((unit) => unit.keyword !== 'false');
-      const failure = units[units.length - 1] ?? verdict.errors[0];
-      const nested = (failure?.instanceLocation ?? '#').slice(1).replaceAll('/', '.');
-
-      throw new Error(`${path}.${field}${nested}: ${failure?.error ?? 'does not match the format'}`);
-    }
-  }
-}