@fougere/schema 0.12.0-alpha.0 → 0.12.2-alpha.0

package/src/validator/FieldDeclarationValidator.ts

@@ -1,9 +1,10 @@
-import { EXTENSION_AXES } from '../axis/Axis.js';
-import { Shapes } from '../axis/shape/Shape.js';
+import { Axes } from '../axis/Axes.js';
 import type { Field } from '../field/Field.js';
-import { isObject, shown } from '../lib/utils.js';
+import { isObject } from '../lib/utils.js';
+import { SchemaError } from '../SchemaError.js';
 import type { ValidationError } from '../lib/ValidationError.js';
 import type { ValidationResult } from '../lib/ValidationResult.js';
+import { JsonSchemaValidator } from './JsonSchemaValidator.js';
 
 export class FieldDeclarationValidator {
   private constructor(private readonly declaration: unknown) {}
@@ -21,7 +22,7 @@ export class FieldDeclarationValidator {
         errors: [
           {
             path: [],
-            message: `Expected an object — got ${shown(declaration)}`,
+            message: `Expected an object — got ${SchemaError.inspect(declaration)}`,
           },
         ],
       };
@@ -29,30 +30,14 @@ export class FieldDeclarationValidator {
 
     const errors: ValidationError[] = [];
 
-    if (!Shapes.is(declaration.shape)) {
-      errors.push({
-        path: ['shape'],
-        message: `Every field states a shape — got ${shown(declaration.shape)}`,
-      });
+    if (declaration.shape === undefined) {
+      errors.push({ path: ['shape'], message: 'Every field states a shape' });
     }
 
-    for (const axis of EXTENSION_AXES) {
-      const declared = declaration[axis.slot];
-      if (declared !== undefined) axis.validator(declared, errors);
-    }
+    errors.push(...JsonSchemaValidator.of(Axes.fieldFormat).refusalsOf(declaration, []));
 
-    if (declaration.meta !== undefined) {
-      if (!isObject(declaration.meta)) {
-        errors.push({
-          path: ['meta'],
-          message: `Expected an object — got ${shown(declaration.meta)}`,
-        });
-      } else if (
-        declaration.meta.description !== undefined &&
-        typeof declaration.meta.description !== 'string'
-      ) {
-        errors.push({ path: ['meta', 'description'], message: 'Expected a string' });
-      }
+    for (const [name, axis] of Axes.entries) {
+      errors.push(...(axis.refusals?.(declaration[name], declaration) ?? []));
     }
 
     return errors.length

package/src/validator/FieldValueValidator.ts

@@ -1,16 +1,16 @@
-import { Validator, format as engineFormats } from '@cfworker/json-schema';
+import { format as engineFormats } from '@cfworker/json-schema';
 import { Boundary } from '../axis/boundary/Boundary.js';
 import { type FormatPredicate } from '../axis/shape/FormatPredicate.js';
-import { Formats } from '../axis/shape/Formats.js';
+import { StringFormats } from '../axis/shape/StringFormats.js';
 import { type Shape } from '../axis/shape/Shape.js';
 import { Shapes } from '../axis/shape/Shape.js';
 import type { Field } from '../field/Field.js';
 import type { Verdict } from '../lib/Verdict.js';
-import type { OutputUnit } from '@cfworker/json-schema';
 import { SchemaError } from '../SchemaError.js';
+import type { JsonSchema } from '../lib/JsonSchema.js';
+import { JsonSchemaValidator } from './JsonSchemaValidator.js';
 
 interface ShapePlan {
-  validator: Validator;
   custom?: FormatPredicate;
   formatName?: string;
 }
@@ -30,7 +30,6 @@ export class FieldValueValidator {
     const type = Shapes.typeOf(shape);
     const base = Shapes.of(shape).base;
     if (value !== null) {
-      if (base?.type === 'object' && !base.properties) return { value };
       if (type === 'date' && value instanceof Date) {
         return Number.isNaN(value.getTime()) ? { message: 'Invalid date' } : { value };
       }
@@ -39,11 +38,14 @@ export class FieldValueValidator {
       }
     }
     const plan = FieldValueValidator.planFor(shape);
-    const result = plan.validator.validate(value);
-    if (!result.valid) return refusalOf(result.errors);
+    const refusal = JsonSchemaValidator.of(shape as JsonSchema).refusalOf(value, []);
+    if (refusal) {
+      return refusal.path.length > 0 ? { message: refusal.message, path: refusal.path } : { message: refusal.message };
+    }
     if (plan.custom && typeof value === 'string' && !plan.custom(value)) {
       return { message: `String does not match format "${plan.formatName}".` };
     }
+
     return { value };
   }
 
@@ -65,49 +67,24 @@ export class FieldValueValidator {
       const base = Shapes.of(shape).base;
       const formatName = base?.type === 'string' ? base.format : undefined;
       plan = {
-        validator: new Validator(shape as object, '2020-12', true),
         custom: formatName === undefined ? undefined : this.customFormatOf(formatName),
         formatName,
       };
       this.plans.set(shape, plan);
     }
+
     return plan;
   }
 
   private static customFormatOf(name: string): FormatPredicate | undefined {
-    const custom = Formats.find(name);
+    const custom = StringFormats.find(name);
     if (!custom && !(name in engineFormats)) {
       throw new SchemaError(
-        `Unknown format: '${name}'. Register it with Formats.register('${name}', …) — ` +
+        `Unknown format: '${name}'. Register it with StringFormats.register('${name}', …) — ` +
           `the engine validates ${Object.keys(engineFormats).length} formats natively and this is not one of them.`,
       );
     }
+
     return custom;
   }
 }
-
-/**
- * The engine states its refusals outermost first, so `errors[0]` on a nested shape is the
- * parent's `Property "street" does not match schema.` — true, and never the reason. The
- * DEEPEST one is the reason, and it is the one that says where.
- */
-function refusalOf(errors: readonly OutputUnit[]): Verdict {
-  const deepest = errors.reduce<OutputUnit | undefined>(
-    (held, one) => (held && depthOf(held) >= depthOf(one) ? held : one),
-    undefined,
-  );
-  if (!deepest) return { message: 'Invalid value' };
-  const path = locationOf(deepest.instanceLocation);
-
-  return path.length > 0 ? { message: deepest.error, path } : { message: deepest.error };
-}
-
-const depthOf = (unit: OutputUnit): number => locationOf(unit.instanceLocation).length;
-
-/** `#/city/zip` — a JSON Pointer fragment, and `~1`/`~0` are how it spells `/` and `~`. */
-const locationOf = (instanceLocation: string): string[] =>
-  instanceLocation
-    .replace(/^#/, '')
-    .split('/')
-    .filter(Boolean)
-    .map((segment) => segment.replace(/~1/g, '/').replace(/~0/g, '~'));

package/src/validator/InputValidator.ts

@@ -1,3 +1,4 @@
+import { Axes } from '../axis/Axes.js';
 import { Boundary } from '../axis/boundary/Boundary.js';
 import { Lifecycle } from '../axis/lifecycle/Lifecycle.js';
 import { Role } from '../axis/role/Role.js';
@@ -20,11 +21,14 @@ export class InputValidator {
     return new InputValidator(fields, options);
   }
 
-  onAbsent(field: Field): 'skip' | 'empty-list' | null {
-    if (Boundary.of(field).readOnly) return 'skip';
-    if (!Lifecycle.of(field).requiredAtCreate) return 'skip';
-    if (Role.of(field).isCollection) return 'empty-list';
-    return null;
+  /**
+   * The three REGISTERED axes decide, and the shape is not one of them — it could not answer
+   * anyway: `nullable(text())` and `optional(text())` both shape `['string', 'null']`, and only
+   * the second dispenses. JSON Schema draws the same line, where `required` is a list on the
+   * OBJECT and never a keyword on the property.
+   */
+  requires(field: Field): boolean {
+    return !Axes.all.some((axis) => axis.admitsAbsence?.(field));
   }
 
   /** Hands on the value it PARSED, so a handler never re-checks a row. */
@@ -43,7 +47,8 @@ export class InputValidator {
     for (const [key, field] of Object.entries(this.fields)) {
       const verdict = this.admit(field, data[key]);
       if (verdict === undefined) continue;
-      if ('message' in verdict) errors.push({ path: [key, ...(verdict.path ?? [])], message: verdict.message });
+      if ('message' in verdict)
+        errors.push({ path: [key, ...(verdict.path ?? [])], message: verdict.message });
       else row[key] = verdict.value;
     }
 
@@ -61,8 +66,11 @@ export class InputValidator {
   private admit(field: Field, value: unknown): Verdict | undefined {
     if (value === undefined) return this.whenAbsent(field);
 
-    if (Boundary.of(field).readOnly) return { message: InputRefusal.readOnly };
-    if (this.options.patch && Lifecycle.of(field).immutable) return { message: InputRefusal.immutable };
+    if (Boundary.of(field).readOnly()) return { message: InputRefusal.readOnly };
+    // The other side of the relation carries the key: there is nothing to write here.
+    if (Role.of(field).isCollection()) return { message: InputRefusal.readOnly };
+    if (this.options.patch && Lifecycle.of(field).immutable())
+      return { message: InputRefusal.immutable };
 
     return FieldValueValidator.of(field).parse(value);
   }
@@ -70,9 +78,6 @@ export class InputValidator {
   private whenAbsent(field: Field): Verdict | undefined {
     if (this.options.patch) return undefined;
 
-    const absence = this.onAbsent(field);
-    if (absence === null) return { message: InputRefusal.required };
-
-    return absence === 'empty-list' ? { value: [] } : undefined;
+    return this.requires(field) ? { message: InputRefusal.required } : undefined;
   }
 }

package/src/validator/JsonSchemaValidator.ts

@@ -0,0 +1,142 @@
+import { Validator, type OutputUnit } from '@cfworker/json-schema';
+import type { JsonSchema } from '../lib/JsonSchema.js';
+import { isObject } from '../lib/utils.js';
+import type { ValidationError } from '../lib/ValidationError.js';
+import { locationOf } from '../lib/ValidationResult.js';
+
+/**
+ * The one door onto the engine: a field's value against its shape, a declaration against the
+ * format of its key. 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 JsonSchemaValidator {
+  private static readonly held = new WeakMap<JsonSchema, JsonSchemaValidator>();
+
+  private first?: Validator;
+  private every?: Validator;
+
+  private constructor(private readonly schema: JsonSchema) {}
+
+  static of(schema: JsonSchema): JsonSchemaValidator {
+    let validator = this.held.get(schema);
+
+    if (!validator) {
+      validator = new JsonSchemaValidator(schema);
+      this.held.set(schema, validator);
+    }
+
+    return validator;
+  }
+
+  /** `refusalOf({ update: 'maybe' }, ['lifecycle'])` → `lifecycle.update: Instance does not match any of ["now","forbidden"].` */
+  refusalOf(value: unknown, path: readonly string[]): ValidationError | undefined {
+    this.first ??= new Validator(this.schema, '2020-12', true);
+
+    const refused = refusedBy(this.first, value);
+
+    if (!Array.isArray(refused)) return under(path, refused);
+    if (!refused.length) return undefined;
+
+    const reasons = named(refused);
+
+    return at(path, reasons.length ? deepestOf(reasons) : refused[0]);
+  }
+
+  /**
+   * One refusal per key, so a declaration hears every fault at once. It reads through an engine
+   * of its own: the other stops at the first, which is what a single value wants.
+   */
+  refusalsOf(value: unknown, path: readonly string[]): ValidationError[] {
+    this.every ??= new Validator(this.schema, '2020-12', false);
+
+    const refused = refusedBy(this.every, value);
+
+    if (!Array.isArray(refused)) return [under(path, refused)];
+    if (!refused.length) return [];
+
+    const faults = [...byKey(named(refused)).values()];
+
+    return faults.length ? faults.map((units) => at(path, deepestOf(units))) : [at(path, refused[0])];
+  }
+}
+
+/** What it refused on, or the member JSON cannot hold — the engine throws on one rather than refusing. */
+function refusedBy(engine: Validator, value: unknown): OutputUnit[] | ValidationError {
+  const json = stated(value);
+
+  try {
+    const verdict = engine.validate(json);
+
+    return verdict.valid ? [] : verdict.errors;
+  } catch {
+    const where = unreadableIn(json) ?? { path: [], value: json };
+
+    return { path: where.path, message: `Expected a JSON value — got ${typeof where.value}` };
+  }
+}
+
+/** `False boolean schema` names nothing: the unit above it carries the offending key. */
+const named = (units: readonly OutputUnit[]): OutputUnit[] =>
+  units.filter((unit) => unit.keyword !== 'false');
+
+/** The engine states its refusals outermost first: the deepest says where, the last one is why. */
+function deepestOf(units: readonly OutputUnit[]): OutputUnit {
+  return units.reduce((held, unit) => (depthOf(held) > depthOf(unit) ? held : unit));
+}
+
+/**
+ * The units of one fault, addressed by the key they happened under. A unit on the value ITSELF
+ * points at a key when another one is deeper — `Property "lifecycle" does not match schema.` —
+ * so it is kept only when it is all there is.
+ */
+function byKey(units: readonly OutputUnit[]): Map<string, OutputUnit[]> {
+  const held = new Map<string, OutputUnit[]>();
+
+  for (const unit of units) {
+    const key = locationOf(unit.instanceLocation)[0] ?? '';
+    held.set(key, [...(held.get(key) ?? []), unit]);
+  }
+
+  if (held.size > 1) held.delete('');
+
+  return held;
+}
+
+const at = (path: readonly string[], unit: OutputUnit): ValidationError => ({
+  path: [...path, ...locationOf(unit.instanceLocation)],
+  message: unit.error,
+});
+
+const under = (path: readonly string[], refusal: ValidationError): ValidationError => ({
+  path: [...path, ...refusal.path],
+  message: refusal.message,
+});
+
+const depthOf = (unit: OutputUnit): number => locationOf(unit.instanceLocation).length;
+
+/** A key set to `undefined` states nothing, as in JSON — and the engine refuses to read one. */
+function stated(value: unknown): unknown {
+  if (Array.isArray(value)) return value.map(stated);
+
+  if (!isObject(value)) return value;
+
+  const present = Object.entries(value).filter(([, member]) => member !== undefined);
+
+  return Object.fromEntries(present.map(([key, member]) => [key, stated(member)]));
+}
+
+/** Where the engine stopped: a function, a symbol or a bigint is not a value JSON holds. */
+function unreadableIn(
+  value: unknown,
+  path: readonly string[] = [],
+): { path: readonly string[]; value: unknown } | undefined {
+  if (['function', 'symbol', 'bigint'].includes(typeof value)) return { path, value };
+
+  if (Array.isArray(value)) {
+    return value.flatMap((member, index) => unreadableIn(member, [...path, String(index)]) ?? [])[0];
+  }
+
+  if (!isObject(value)) return undefined;
+
+  return Object.entries(value).flatMap(([key, member]) => unreadableIn(member, [...path, key]) ?? [])[0];
+}

package/src/vocabulary/preset/created.ts

@@ -1,8 +1,8 @@
-import { Field } from '../../field/Field.js';
+import { Field, type Described } from '../../field/Field.js';
 import { date } from '../primitive/date.js';
 
-export function created(): Field<Date> {
-  return date().with({
+export function created(opts?: Described): Field<Date> {
+  return date(opts).with({
     lifecycle: { create: 'now', update: 'forbidden' },
   });
 }

package/src/vocabulary/preset/updated.ts

@@ -1,7 +1,8 @@
+import { Field, type Described } from '../../field/Field.js';
 import { created } from './created.js';
-import { Field } from '../../field/Field.js';
 
-export function updated(): Field<Date> {
-  const base = created();
+export function updated(opts?: Described): Field<Date> {
+  const base = created(opts);
+
   return base.with({ lifecycle: { ...base.lifecycle, update: 'now' } });
 }

package/src/vocabulary/primitive/bool.ts

@@ -1,10 +1,5 @@
-import { Field } from '../../field/Field.js';
+import { Field, type Shared } from '../../field/Field.js';
 
-export function bool(opts?: { default?: boolean; description?: string }): Field<boolean> {
-  return new Field<boolean>({
-    shape: { type: 'boolean' },
-    lifecycle:
-      opts?.default !== undefined ? { create: { value: opts.default } } : undefined,
-    meta: opts?.description !== undefined ? { description: opts.description } : undefined,
-  });
+export function bool(opts?: Shared<boolean>): Field<boolean> {
+  return new Field<boolean>({ shape: { type: 'boolean' } }).setShared(opts);
 }

package/src/vocabulary/primitive/date.ts

@@ -1,10 +1,11 @@
-import { Field } from '../../field/Field.js';
+import { Field, type Shared } from '../../field/Field.js';
 
 /**
  * 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' } });
+export function date(opts?: Shared<Date>): Field<Date> {
+  return new Field<Date>({ shape: { type: 'string', format: 'date-time' } }).setShared(
+    opts,
+  );
 }

package/src/vocabulary/primitive/json.ts

@@ -1,29 +1,44 @@
-import { Field } from '../../field/Field.js';
+import { Field, type Shared } from '../../field/Field.js';
 import type { SchemaView } from '../../SchemaView.js';
 import { InputValidator } from '../../validator/InputValidator.js';
+import { SchemaError } from '../../SchemaError.js';
 
-export function json<T = unknown>(): Field<T>;
+type Entity = SchemaView & (new (...args: never[]) => unknown);
+
+export function json<T = unknown>(opts?: Shared<T>): Field<T>;
 export function json<E extends SchemaView & (new (...args: any[]) => any)>(
   of: E,
+  opts?: Shared<InstanceType<E>>,
 ): Field<InstanceType<E>>;
+
 /**
- * `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' } });
-  const fields = of.getFields();
+export function json(
+  of?: Entity | Shared<unknown>,
+  opts?: Shared<unknown>,
+): Field<unknown> {
+  const [schema, shared] = typeof of === 'function' ? [of, opts] : [undefined, of];
+
+  if (schema && typeof schema.getFields !== 'function')
+    throw new SchemaError(
+      'json() takes an entity, such as json(Address) — got a function that is not one',
+    );
+
+  if (!schema) return new Field({ shape: { type: 'object' } }).setShared(shared);
+
+  const fields = schema.getFields();
   const validator = InputValidator.of(fields);
   const properties: Record<string, unknown> = {};
   const required: string[] = [];
+
   for (const [key, field] of Object.entries(fields)) {
-    properties[key] = field.meta?.description
-      ? { ...field.shape, description: field.meta.description }
-      : field.shape;
-    if (validator.onAbsent(field) === null) required.push(key);
+    properties[key] = field.shape;
+
+    if (validator.requires(field)) required.push(key);
   }
+
   return new Field({
     shape: { type: 'object', properties, ...(required.length ? { required } : {}) },
-  });
+  }).setShared(shared);
 }

package/src/vocabulary/primitive/list.ts

@@ -1,22 +1,29 @@
-import { Field } from '../../field/Field.js';
+import { Field, type Shared } from '../../field/Field.js';
 import { SchemaError } from '../../SchemaError.js';
 
-export interface ListOptions {
+export interface ListOptions<T = unknown> extends Shared<T[]> {
   min?: number;
   max?: number;
 }
 
 /**
- * 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.
+ * A list of values. It keeps the shape of the item and nothing else: `nullable()` and a
+ * `description` write in the shape, so they work. A rule writes beside it, and an item of a
+ * list has no key, no column and no name to keep it on.
  * `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)
+export function list<T>(field: Field<T>, opts?: ListOptions<T>): Field<T[]> {
+  if (field.hasAxes())
     throw new SchemaError(
-      'list() takes a value field (text(), number()…) — a relation has no value shape',
+      'list() takes a value, not a rule. Put the rule on the list: unique(list(text())).',
     );
+
   return new Field<T[]>({
-    shape: { type: 'array', items: item.shape, minItems: opts?.min, maxItems: opts?.max },
-  });
+    shape: {
+      type: 'array',
+      items: field.shape,
+      minItems: opts?.min,
+      maxItems: opts?.max,
+    },
+  }).setShared(opts);
 }

package/src/vocabulary/primitive/many.ts

@@ -1,17 +1,16 @@
 import { type EntityConstructor } from '../../axis/role/EntityConstructor.js';
 import { Relation } from '../../axis/role/Relation.js';
-import { Field } from '../../field/Field.js';
+import { Field, type Described } from '../../field/Field.js';
 
 /**
- * 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),
+  opts?: Described,
 ): Field<InstanceType<E>[]> {
   return new Field<InstanceType<E>[]>({
     shape: { type: 'array' },
     role: { relation: Relation.many(target) },
-  });
+  }).setShared(opts);
 }

package/src/vocabulary/primitive/number.ts

@@ -1,11 +1,9 @@
-import { Field } from '../../field/Field.js';
+import { Field, type Shared } from '../../field/Field.js';
 
-export interface NumberOptions {
+export interface NumberOptions extends Shared<number> {
   min?: number;
   max?: number;
   integer?: boolean;
-  default?: number;
-  description?: string;
 }
 
 export function number(opts?: NumberOptions): Field<number> {
@@ -15,8 +13,5 @@ export function number(opts?: NumberOptions): Field<number> {
       minimum: opts?.min,
       maximum: opts?.max,
     },
-    lifecycle:
-      opts?.default !== undefined ? { create: { value: opts.default } } : undefined,
-    meta: opts?.description !== undefined ? { description: opts.description } : undefined,
-  });
+  }).setShared(opts);
 }

package/src/vocabulary/primitive/oneOf.ts

@@ -1,32 +1,48 @@
-import { Field } from '../../field/Field.js';
+import { Field, type Shared } from '../../field/Field.js';
+import type { Shape } from '../../axis/shape/Shape.js';
+import { isArrayOf, isObject } from '../../lib/utils.js';
+import { SchemaError } from '../../SchemaError.js';
 
-interface OneOfOptions<V extends string = string> {
-  description?: string;
-  default?: V;
-}
+type Values = readonly [string, ...string[]] | readonly [number, ...number[]];
 
-export function oneOf<const T extends readonly string[]>(
-  ...values: [...T]
-): Field<T[number]>;
-export function oneOf<const T extends readonly string[]>(
-  ...args: [...T, OneOfOptions<T[number]>]
+export function oneOf<const T extends Values>(...values: [...T]): Field<T[number]>;
+
+export function oneOf<const T extends Values>(
+  ...args: [...T, Shared<T[number]>]
 ): Field<T[number]>;
+
 /**
- * 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]>]
+export function oneOf<const T extends Values>(
+  ...args: [...T] | [...T, Shared<T[number]>]
 ): Field<T[number]> {
-  const last = args[args.length - 1];
-  const hasOpts = typeof last === 'object' && last !== null && !Array.isArray(last);
-  const values = (hasOpts ? args.slice(0, -1) : args) as unknown as readonly string[];
-  const opts = hasOpts ? (last as OneOfOptions) : {};
-  return new Field<T[number]>({
-    shape: { type: 'string', enum: values },
-    lifecycle:
-      opts.default !== undefined ? { create: { value: opts.default } } : undefined,
-    meta: opts.description !== undefined ? { description: opts.description } : undefined,
-  });
+  const given: readonly unknown[] = args;
+  const last = given.at(-1);
+
+  const opts = isObject(last) ? last : undefined;
+  const values = opts ? given.slice(0, -1) : given;
+
+  let shape: Shape | undefined = undefined;
+
+  if (values.length === 0)
+    throw new SchemaError(
+      'oneOf() takes strings or numbers, then an optional object of options', { received: given },
+    );
+
+  if (isArrayOf(values, (value) => typeof value === 'string'))
+    shape = { type: 'string', enum: values };
+
+  if (isArrayOf(values, (value) => typeof value === 'number'))
+    shape = {
+      type: values.every(Number.isInteger) ? 'integer' : 'number',
+      enum: values,
+    };
+
+  if (shape === undefined)
+    throw new SchemaError(
+      'oneOf() takes strings or numbers, then an optional object of options', { received: given },
+    );
+
+  return new Field<T[number]>({ shape }).setShared(opts);
 }