@fougere/schema 0.6.0-alpha.0 → 0.8.0-alpha.0

package/src/schema/axis/role/Role.ts

@@ -1,56 +0,0 @@
-import { FieldGroup } from "../../fields/constraint/FieldGroup.js";
-import { Unique } from "../../fields/constraint/Unique.js";
-import type { EntityConstructor, Relation } from "./Relation.js";
-
-export interface RoleRules {
-  primary?: boolean;
-  index?: boolean;
-  relation?: Relation;
-  rules?: readonly FieldGroup[];
-}
-
-export class Role implements RoleRules {
-  readonly primary?: boolean;
-  readonly index?: boolean;
-  readonly relation?: Relation;
-  readonly rules?: readonly FieldGroup[];
-
-  private constructor(declared: RoleRules = {}) {
-    this.primary = declared.primary;
-    this.index = declared.index;
-    this.relation = declared.relation;
-    this.rules = declared.rules;
-  }
-
-  static of(field: { role?: RoleRules }): Role {
-    return new Role(field.role);
-  }
-
-  /** A group written with no members means "this field": only the key it is declared under resolves it. */
-  static resolvedOn(role: RoleRules | undefined, key?: string): RoleRules | undefined {
-    let rules = FieldGroup.normalize(role?.rules, (members) => new Unique(members));
-    if (rules && key !== undefined && rules.some((group) => group.isSelf))
-      rules = rules.map((group) => group.resolvedOn(key));
-    return rules === role?.rules ? role : { ...role, rules };
-  }
-
-  get isPrimary(): boolean {
-    return this.primary === true;
-  }
-
-  get isIndexed(): boolean {
-    return this.index === true;
-  }
-
-  get isCollection(): boolean {
-    return this.relation?.kind === "many";
-  }
-
-  get isReference(): boolean {
-    return this.relation?.kind === "one";
-  }
-
-  get target(): EntityConstructor | undefined {
-    return this.relation?.to();
-  }
-}

package/src/schema/axis/shape/Formats.ts

@@ -1,22 +0,0 @@
-export type StringFormat =
-  | 'date-time'
-  | 'date'
-  | 'time'
-  | 'email'
-  | 'uuid'
-  | 'uri'
-  | (string & {});
-
-export type FormatPredicate = (value: string) => boolean;
-
-export class Formats {
-  private static readonly registry = new Map<string, FormatPredicate>();
-
-  static register(name: string, predicate: FormatPredicate): void {
-    this.registry.set(name, predicate);
-  }
-
-  static resolve(name: string): FormatPredicate | undefined {
-    return this.registry.get(name);
-  }
-}

package/src/schema/fields/FieldSet.ts

@@ -1,63 +0,0 @@
-import { Role } from '../axis/role/Role.js';
-import { FieldGroup } from './constraint/FieldGroup.js';
-import { Unique } from './constraint/Unique.js';
-import type { CompositeUnique } from '../../entity/EntityDeclarations.js';
-import { Field, type FieldName, type Fields } from './Field.js';
-
-export class FieldSet<TFields extends Fields = Fields> {
-  private constructor(private readonly fields: TFields) {}
-
-  static of<TFields extends Fields>(fields: TFields): FieldSet<TFields> {
-    return new FieldSet(fields);
-  }
-
-  /**
-   * Every entry through the field door, then the groups declared over several of them.
-   * A group written here names its members; one written on a field named itself, and the
-   * key it sat under resolved it.
-   */
-  static declared<TFields extends Fields>(
-    declared: TFields,
-    unique?: CompositeUnique<TFields>,
-  ): TFields {
-    let fields: Fields = {};
-    for (const [key, field] of Object.entries(declared))
-      fields[key] = new Field(field, key);
-    for (const group of unique ?? []) fields = new Unique(group).onto(fields);
-    return fields as TFields;
-  }
-
-  /**
-   * The name of the field that carries `primary`, or `undefined` when none does.
-   *
-   * `Role.of(field).isPrimary` answers about ONE field; this answers about a shape, which
-   * is the question every reader actually had. It was the same three lines spelled five
-   * times — a mirror's key, a form's row identity, GraphQL's node id, the DDL's primary
-   * key and the storage's `findById` column — so a shape with two primaries meant whichever
-   * one that loop happened to see first, five times over.
-   *
-   * The absence is answered and not defaulted: `'id'` is a fine fallback for a form and a
-   * lie for a DDL, so the caller decides.
-   */
-  get primary(): FieldName<TFields> | undefined {
-    const primaries = Object.entries(this.fields)
-      .filter(([, field]) => Role.of(field).isPrimary)
-      .map(([name]) => name);
-
-    if (primaries.length > 1) {
-      throw new Error(
-        `FieldSet.primary: ${primaries.map((name) => JSON.stringify(name)).join(', ')} all declare ` +
-          '`primary`; a field set can have only one primary field.',
-      );
-    }
-
-    return primaries[0] as FieldName<TFields> | undefined;
-  }
-
-  get uniqueGroups(): CompositeUnique<TFields> | undefined {
-    const groups = FieldGroup.groupsOf(this.fields, Unique);
-    return groups.length
-      ? (groups.map((group) => [...group.members]) as unknown as CompositeUnique<TFields>)
-      : undefined;
-  }
-}

package/src/schema/fields/constraint/FieldGroup.ts

@@ -1,84 +0,0 @@
-import type { Field, Fields } from '../Field.js';
-
-export abstract class FieldGroup {
-  constructor(readonly members: readonly string[]) {}
-
-  protected withMembers(members: readonly string[]): this {
-    return new (this.constructor as new (members: readonly string[]) => this)(members);
-  }
-
-  get isSelf(): boolean {
-    return this.members.length === 0;
-  }
-
-  resolvedOn(ownKey: string): this {
-    return this.isSelf ? this.withMembers([ownKey]) : this;
-  }
-
-  covers(key: string): boolean {
-    return this.members.includes(key);
-  }
-
-  equals(other: FieldGroup): boolean {
-    return (
-      this.constructor === other.constructor &&
-      this.members.length === other.members.length &&
-      this.members.every((member, i) => member === other.members[i])
-    );
-  }
-
-  onto(fields: Fields): Fields {
-    const missing = this.members.filter((key) => !(key in fields));
-    if (missing.length)
-      throw new Error(
-        `${this.constructor.name.toLowerCase()}: [${this.members.join(', ')}] names ` +
-          `${missing.map((m) => `'${m}'`).join(', ')}, which the entity does not declare.`,
-      );
-
-    const out: Fields = { ...fields };
-    for (const key of this.members) {
-      const field = out[key]!;
-      out[key] = field.with({
-        role: { ...field.role, rules: [...(field.role?.rules ?? []), this] },
-      });
-    }
-    return out;
-  }
-
-  rename(map: (key: string) => string | undefined): this | null {
-    if (this.isSelf) return this;
-    const carried = this.members.map(map);
-    return carried.every((key): key is string => key !== undefined)
-      ? this.withMembers(carried)
-      : null;
-  }
-
-  toJSON(): string[] {
-    return [...this.members];
-  }
-
-  static normalize<R extends FieldGroup>(
-    groups: readonly (R | readonly string[])[] | undefined,
-    make: (members: readonly string[]) => R,
-  ): readonly R[] | undefined {
-    if (!groups) return undefined;
-    return groups.map((group) =>
-      group instanceof FieldGroup ? (group as R) : make(group),
-    );
-  }
-
-  static on<R extends FieldGroup>(field: Field, kind: Function & { prototype: R }): R[] {
-    return (field.role?.rules ?? []).filter((rule): rule is R => rule instanceof kind);
-  }
-
-  static groupsOf<R extends FieldGroup>(
-    fields: Fields,
-    kind: Function & { prototype: R },
-  ): R[] {
-    const seen = new Map<string, R>();
-    for (const field of Object.values(fields))
-      for (const rule of FieldGroup.on(field, kind))
-        if (rule.members.length > 1) seen.set(rule.members.join(' '), rule);
-    return [...seen.values()];
-  }
-}

package/src/schema/fields/constraint/Unique.ts

@@ -1,3 +0,0 @@
-import { FieldGroup } from './FieldGroup.js';
-
-export class Unique extends FieldGroup {}