@fougere/schema 0.1.0-alpha.0

package/dist/projections/lifecycle.js

@@ -0,0 +1,115 @@
+/**
+ * The lifecycle axis, realized — once, for every storage.
+ *
+ * `validation.ts` states the split: the judge answers "is this value legal?" and never
+ * fills a hole; filling it — stamp `'now'`, apply `{ value }`, call `{ generate }` — is
+ * the storage's role at the point of persistence. The split is right. What was missing
+ * is that the framework shipped the RULE and never its realization, so each storage
+ * rewrote it and they drifted:
+ *
+ * - `schema-sql` realized `{ generate }` and `'now'` in its ORM, and `{ value }` in its
+ *   DDL — as a column `DEFAULT` the database fills. A mechanism only SQL has.
+ * - The Nuxt module's fallback ORM realized none of the three: its signature is
+ *   `(_entity, _name)`, both ignored, so it forces the name `id` and a random uuid.
+ * - A third-party adapter (MongoDB, written outside the repo on 2026-08-08) found the
+ *   gap the only way available: a test that expected `'draft'` and got `undefined`.
+ *
+ * Measured, one entity, `oneOf('draft','published',{ default:'draft' })`: SQLite answered
+ * `'draft'`, MongoDB answered `undefined`. Same declaration, same port, two answers.
+ *
+ * So the rule and its realization live together now, and a storage adapter calls this
+ * instead of re-deriving it. `update: 'forbidden'` is NOT here: refusing a value is a
+ * judgment, and the façade already does it (`validation.ts`, patch mode).
+ */
+import { resolveCustomGenerator } from '../field/index.js';
+import { createId } from '@paralleldrive/cuid2';
+/**
+ * Resolve a generator TOKEN to a function: a custom name registered via
+ * `registerGenerator` wins, then the built-ins. An unknown name throws — loud and
+ * local, instead of a silent divergence between two storages.
+ *
+ * The built-ins used to live storage-side, which put the inversion in plain sight: a
+ * generator YOU invent travelled to every adapter, and the three the framework ships
+ * did not.
+ */
+function generatorFor(ref) {
+    const custom = resolveCustomGenerator(ref);
+    if (custom)
+        return custom;
+    switch (ref) {
+        case 'cuid2': return createId;
+        case 'uuid': return () => globalThis.crypto.randomUUID();
+        case 'nanoid': {
+            return () => {
+                const bytes = new Uint8Array(21);
+                globalThis.crypto.getRandomValues(bytes);
+                const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+                return Array.from(bytes, (b) => alphabet[b & 63]).join('');
+            };
+        }
+        default:
+            throw new Error(`Unknown generator '${ref}' — register it with registerGenerator('${ref}', fn)`);
+    }
+}
+/**
+ * Fill what the entity says the system writes at creation.
+ *
+ * A value the caller supplied is never touched, including `null` — presence is the
+ * test, not truthiness, so `archivedAt: null` stays null rather than being re-filled.
+ *
+ * `'now'` produces a `Date`, the value the field declares. The storage converts it if
+ * its driver needs something else (`schema-sql/src/values.ts` does exactly that) —
+ * which is the same direction every other value travels.
+ */
+export function applyCreate(fields, input) {
+    const out = { ...input };
+    const instant = Date.now();
+    for (const [name, field] of Object.entries(fields)) {
+        if (name in out)
+            continue;
+        const create = field.lifecycle?.create;
+        if (create === 'now') {
+            // One instant, one Date PER FIELD. `auto()` and `updated()` on the same entity
+            // would otherwise hold the same object, so mutating `updatedAt` would move an
+            // immutable `createdAt` with it — invisible where a storage serializes on write
+            // (SQL), lasting where it does not (an in-memory store keeps the row as handed).
+            out[name] = new Date(instant);
+        }
+        else if (typeof create === 'object' && create !== null) {
+            if ('value' in create)
+                out[name] = freshValue(create.value);
+            else if ('generate' in create)
+                out[name] = generatorFor(String(create.generate))();
+        }
+        // `'optional'` and an absent rule both mean: the system writes nothing here.
+    }
+    return out;
+}
+/**
+ * A declared default is written into every row, so handing out the declaration itself
+ * would alias every row to it — mutate one, mutate the field and all its siblings.
+ *
+ * Every default the vocabulary can express is a primitive (`text`, `number`, `bool`,
+ * `oneOf`; `list` and `json` take none), so this only pays for itself under the escape
+ * hatch — `createField({ lifecycle: { create: { value: {…} } } })`. Cheap insurance
+ * against the one failure mode nobody would ever debug from the symptom.
+ */
+function freshValue(value) {
+    if (value === null || typeof value !== 'object')
+        return value;
+    return structuredClone(value);
+}
+/**
+ * Fill what the entity says the system writes at every update — `updated()`, and
+ * nothing else. A supplied value wins, same rule as create.
+ */
+export function applyUpdate(fields, patch) {
+    const out = { ...patch };
+    const instant = Date.now();
+    for (const [name, field] of Object.entries(fields)) {
+        if (field.lifecycle?.update === 'now' && !(name in out))
+            out[name] = new Date(instant);
+    }
+    return out;
+}
+//# sourceMappingURL=lifecycle.js.map

package/dist/projections/lifecycle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.js","sourceRoot":"","sources":["../../src/projections/lifecycle.ts"],"names":[],"mappings":"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"}

package/dist/projections/reconstruct.d.ts

@@ -0,0 +1,36 @@
+import { type Field, type Fields } from '../field/index.js';
+import { type SchemaConstructor, type SchemaViewInfer } from '../entity.js';
+import { type SchemaBundle, type SchemaDescriptor } from './card.js';
+/**
+ * The field map a stated row shape implies.
+ *
+ * Every member is marked auto-at-creation, so `CtorInput` asks for nothing: a card
+ * describes rows as they are READ, and "what a caller must supply at creation" is a
+ * different question — one `required` answers, and one a synced consumer never asks,
+ * since it calls the host rather than constructing.
+ */
+type FieldsOf<T> = {
+    [K in keyof T]-?: Field<T[K], true>;
+};
+/**
+ * Read a lone card back into a working schema — THE single reconstructor. The result
+ * carries its `~standard` (live validation) rebuilt locally: the descriptor crosses
+ * the wire as data, the behaviour is reconstituted here. Relations stay name stand-ins
+ * (no set to resolve against — use {@link reconstructSet} for live targets).
+ *
+ * `T` states the shape of a row, and that is what makes a rebuilt schema a CLASS rather
+ * than a type and a value declared side by side: `class Post extends reconstruct<{…}>(card) {}`
+ * is one declaration carrying both, exactly like `class Post extends entity({…}) {}`.
+ * Without it the instance type is an index signature, so a synced entity validated
+ * perfectly and taught the compiler nothing — `post.titel` compiled.
+ */
+export declare function reconstruct<T = SchemaViewInfer<Fields>>(descriptor: SchemaDescriptor): SchemaConstructor<FieldsOf<T>>;
+/**
+ * Read a whole bundle back into live schemas, keyed by name — THE set reconstructor.
+ * Every entity is rebuilt against a shared `$defs` resolver, so a relation's `to()`
+ * hands back the real reconstructed target (feeds adapters), not a name stand-in.
+ * Targets absent from the set (external/cross-frond `$ref`) keep the stand-in.
+ */
+export declare function reconstructSet(bundle: SchemaBundle): Record<string, SchemaConstructor<Fields>>;
+export {};
+//# sourceMappingURL=reconstruct.d.ts.map

package/dist/projections/reconstruct.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconstruct.d.ts","sourceRoot":"","sources":["../../src/projections/reconstruct.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,KAAK,EACV,KAAK,MAAM,EAGZ,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAA2B,KAAK,iBAAiB,EAAE,KAAK,eAAe,EAAE,MAAM,cAAc,CAAC;AACrG,OAAO,EAIL,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACtB,MAAM,WAAW,CAAC;AAsHnB;;;;;;;GAOG;AACH,KAAK,QAAQ,CAAC,CAAC,IAAI;KAAG,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC;CAAE,CAAC;AAE3D;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,CAAC,GAAG,eAAe,CAAC,MAAM,CAAC,EACrD,UAAU,EAAE,gBAAgB,GAC3B,iBAAiB,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAEhC;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,MAAM,CAAC,CAAC,CAc9F"}

package/dist/projections/reconstruct.js

@@ -0,0 +1,149 @@
+import { createField, } from '../field/index.js';
+import { createSchemaConstructor } from '../entity.js';
+import { clean, } from './card.js';
+// ─── reconstruct — card → schema (the single reconstructor) ────────
+/**
+ * Read a JSON Schema property back into a Fougère shape. The `type` travels
+ * VERBATIM — nullability is the `[T,'null']` union on both sides, so there is
+ * nothing to split; only the keyword subset of the base type is picked.
+ */
+function reconstructShape(prop) {
+    const types = Array.isArray(prop.type) ? prop.type : prop.type ? [prop.type] : [];
+    const base = types.find((t) => t !== 'null');
+    if (base === undefined)
+        return undefined;
+    const type = prop.type;
+    // `array` is two distinct things: with `items` it is a value list (a real shape);
+    // without, it is a bare `many` relation marker — no shape, the role carries it.
+    if (base === 'array') {
+        if (!prop.items)
+            return undefined;
+        const items = reconstructShape(prop.items);
+        return clean({ type, items, minItems: prop.minItems, maxItems: prop.maxItems });
+    }
+    switch (base) {
+        case 'string':
+            return clean({ type, minLength: prop.minLength, maxLength: prop.maxLength, pattern: prop.pattern, enum: prop.enum, format: prop.format });
+        case 'number':
+        case 'integer':
+            return clean({ type, minimum: prop.minimum, maximum: prop.maximum });
+        case 'boolean':
+            return { type };
+        default: // 'object' or anything unrecognised → opaque value (nesting travels verbatim)
+            return clean({ type, properties: prop.properties, required: prop.required });
+    }
+}
+function reconstructRole(role, resolve) {
+    const out = {};
+    if (role.primary)
+        out.primary = true;
+    // Members arrive spelled out and stay that way — a single-member group read back as the
+    // empty self-reference would re-describe identically but lose the distinction for no
+    // gain. `uniqueMembers` treats a named group as already resolved.
+    if (role.unique?.length)
+        out.unique = role.unique.map((group) => [...group]);
+    if (role.index)
+        out.index = true;
+    if (role.relation) {
+        const name = role.relation.to;
+        out.relation = {
+            // `to` is the `$ref` (a name). With a resolver (a bundle), it hands back the real
+            // reconstructed target — adapters can read its fields. Lazy, so circular relations
+            // resolve fine. Without one (a lone card), a name-only stand-in: enough to validate
+            // (`kind`) and re-describe identically, but not to feed an adapter.
+            to: () => resolve?.(name) ?? { name },
+            kind: role.relation.kind,
+            ...(role.relation.onDelete ? { onDelete: role.relation.onDelete } : {}),
+        };
+    }
+    return out;
+}
+function reconstructField(prop, resolve) {
+    const ext = prop['x-fougere'];
+    return createField({
+        shape: reconstructShape(prop),
+        role: ext?.role ? reconstructRole(ext.role, resolve) : undefined,
+        // The normal forms are pure JSON — they travelled verbatim, they read back verbatim.
+        lifecycle: ext?.lifecycle,
+        boundary: ext?.boundary,
+        meta: prop.description !== undefined ? { description: prop.description } : undefined,
+    });
+}
+/**
+ * The entity-level groups implied by the fields — the inverse of
+ * `projectUniqueOntoFields`. Only groups of more than one member: a lone `unique(slug)`
+ * is fully stated by the field's own role, and listing it here would make `getUnique()`
+ * answer a composite the author never declared.
+ */
+function compositeFromFields(fields) {
+    const seen = new Map();
+    for (const field of Object.values(fields)) {
+        for (const group of field.role?.unique ?? []) {
+            if (group.length < 2)
+                continue;
+            // A key that cannot collide with a field name — `JSON.stringify` rather than a
+            // separator byte: a NUL in the source made every `grep` read this whole file as
+            // binary and skip it silently, a poor price for a de-duplication key.
+            seen.set(JSON.stringify(group), [...group]);
+        }
+    }
+    return seen.size ? [...seen.values()] : undefined;
+}
+/** Build a live schema from a card; `resolve` wires relation targets when in a bundle. */
+function buildSchema(descriptor, resolve) {
+    const fields = {};
+    for (const [key, prop] of Object.entries(descriptor.properties)) {
+        fields[key] = reconstructField(prop, resolve);
+    }
+    // Recover the entity-level declaration from what the members carry. The card holds the
+    // fact once per member; a group of two arrives twice, so the set is de-duplicated —
+    // `getUnique()` then answers what the original author wrote, and the DDL on this side
+    // emits the same constraint as the DDL on the other.
+    const schema = createSchemaConstructor(fields, undefined, undefined, {}, compositeFromFields(fields));
+    // The name is the identity everything downstream keys on — the registration key, the
+    // table, the GraphQL type, what a relation's `to` points at. `describe` writes it as
+    // `title`; dropping it here left a rebuilt schema called `Schema`, so a card could not
+    // round-trip and an adapter standing on one had no entity name to work from.
+    // `reconstructSet` still overrides with the bundle key, which is the more specific truth.
+    if (descriptor.title) {
+        Object.defineProperty(schema, 'name', { value: descriptor.title, configurable: true });
+    }
+    return schema;
+}
+/**
+ * Read a lone card back into a working schema — THE single reconstructor. The result
+ * carries its `~standard` (live validation) rebuilt locally: the descriptor crosses
+ * the wire as data, the behaviour is reconstituted here. Relations stay name stand-ins
+ * (no set to resolve against — use {@link reconstructSet} for live targets).
+ *
+ * `T` states the shape of a row, and that is what makes a rebuilt schema a CLASS rather
+ * than a type and a value declared side by side: `class Post extends reconstruct<{…}>(card) {}`
+ * is one declaration carrying both, exactly like `class Post extends entity({…}) {}`.
+ * Without it the instance type is an index signature, so a synced entity validated
+ * perfectly and taught the compiler nothing — `post.titel` compiled.
+ */
+export function reconstruct(descriptor) {
+    return buildSchema(descriptor);
+}
+/**
+ * Read a whole bundle back into live schemas, keyed by name — THE set reconstructor.
+ * Every entity is rebuilt against a shared `$defs` resolver, so a relation's `to()`
+ * hands back the real reconstructed target (feeds adapters), not a name stand-in.
+ * Targets absent from the set (external/cross-frond `$ref`) keep the stand-in.
+ */
+export function reconstructSet(bundle) {
+    const map = {};
+    const resolve = (name) => map[name.toLowerCase()];
+    const out = {};
+    for (const [name, descriptor] of Object.entries(bundle.$defs)) {
+        const schema = buildSchema(descriptor, resolve);
+        // Name the rebuilt class after its key so re-describing it yields the same `to` name
+        // (describe reads `relation.to().name`). Lazy `to` means the map need only be full
+        // before any `.to()` call — true once this loop ends.
+        Object.defineProperty(schema, 'name', { value: name, configurable: true });
+        map[name.toLowerCase()] = schema;
+        out[name] = schema;
+    }
+    return out;
+}
+//# sourceMappingURL=reconstruct.js.map

package/dist/projections/reconstruct.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconstruct.js","sourceRoot":"","sources":["../../src/projections/reconstruct.ts"],"names":[],"mappings":"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"}

package/dist/projections/source.d.ts

@@ -0,0 +1,41 @@
+import type { Fields, SchemaLike } from '../field/index.js';
+import type { SchemaDescriptor } from './card.js';
+/**
+ * The two forms a schema reaches an adapter in — and the single reader that takes both.
+ *
+ * An adapter has never needed the class, only its fields. In-process it gets the class
+ * because the class is there; from a remote or foreign frond it gets the card, because a
+ * class does not cross a wire. Naming that union here is what lets one projection serve
+ * both, instead of each adapter growing its own branch.
+ *
+ * The card was built for exactly this and had no in-repo reader: every adapter called
+ * `getFields()` on the live class, so writing a Fougere adapter meant being inside the
+ * repo, in TypeScript, with the class in hand.
+ */
+export type SchemaSource = SchemaLike | SchemaDescriptor;
+/**
+ * Normalize a source to a live schema — reconstructing a card, passing a class through.
+ *
+ * This is what an adapter reaching for the schema MORE THAN ONCE should call, once, at its
+ * boundary: `reconstruct` runs per call (6.5 µs for a 17-field entity), so a component that
+ * reads fields in two places would otherwise rebuild the schema twice and hold two
+ * unrelated field objects. Normalize at the edge, then nothing downstream knows the
+ * difference — which is the point.
+ */
+export declare function schemaOf(source: SchemaSource): SchemaLike;
+/**
+ * The fields an adapter projects from, whichever form it was handed — {@link schemaOf}
+ * for the single-read case.
+ *
+ * Cost: nothing for a class. For a card, one `reconstruct` — measured at 6.5 µs for a
+ * 17-field entity, paid once per entity when the adapter builds, never per request. Read
+ * twice and you pay twice: hold the result, or normalize with `schemaOf` instead.
+ */
+export declare function fieldsOf(source: SchemaSource): Fields;
+/**
+ * The composite unique groups, whichever form. A bare wrapper (a view mid-derivation)
+ * carries no `getUnique` and answers `undefined`; a card's groups are recovered from what
+ * its members carry, so `reconstruct` has already restored them by the time this reads.
+ */
+export declare function uniqueOf(source: SchemaSource): ReadonlyArray<ReadonlyArray<string>> | undefined;
+//# sourceMappingURL=source.d.ts.map

package/dist/projections/source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source.d.ts","sourceRoot":"","sources":["../../src/projections/source.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAGlD;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,YAAY,GAAG,UAAU,GAAG,gBAAgB,CAAC;AAOzD;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,YAAY,GAAG,UAAU,CAEzD;AAED;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAErD;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,YAAY,GAAG,aAAa,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,GAAG,SAAS,CAE/F"}

package/dist/projections/source.js

@@ -0,0 +1,37 @@
+import { reconstruct } from './reconstruct.js';
+/** A card is the plain document — no behaviour, so no `getFields`. */
+function isDescriptor(source) {
+    return typeof source.getFields !== 'function';
+}
+/**
+ * Normalize a source to a live schema — reconstructing a card, passing a class through.
+ *
+ * This is what an adapter reaching for the schema MORE THAN ONCE should call, once, at its
+ * boundary: `reconstruct` runs per call (6.5 µs for a 17-field entity), so a component that
+ * reads fields in two places would otherwise rebuild the schema twice and hold two
+ * unrelated field objects. Normalize at the edge, then nothing downstream knows the
+ * difference — which is the point.
+ */
+export function schemaOf(source) {
+    return isDescriptor(source) ? reconstruct(source) : source;
+}
+/**
+ * The fields an adapter projects from, whichever form it was handed — {@link schemaOf}
+ * for the single-read case.
+ *
+ * Cost: nothing for a class. For a card, one `reconstruct` — measured at 6.5 µs for a
+ * 17-field entity, paid once per entity when the adapter builds, never per request. Read
+ * twice and you pay twice: hold the result, or normalize with `schemaOf` instead.
+ */
+export function fieldsOf(source) {
+    return schemaOf(source).getFields();
+}
+/**
+ * The composite unique groups, whichever form. A bare wrapper (a view mid-derivation)
+ * carries no `getUnique` and answers `undefined`; a card's groups are recovered from what
+ * its members carry, so `reconstruct` has already restored them by the time this reads.
+ */
+export function uniqueOf(source) {
+    return schemaOf(source).getUnique?.();
+}
+//# sourceMappingURL=source.js.map

package/dist/projections/source.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"source.js","sourceRoot":"","sources":["../../src/projections/source.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAgB/C,sEAAsE;AACtE,SAAS,YAAY,CAAC,MAAoB;IACxC,OAAO,OAAQ,MAAqB,CAAC,SAAS,KAAK,UAAU,CAAC;AAChE,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,QAAQ,CAAC,MAAoB;IAC3C,OAAO,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;AAC7D,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,QAAQ,CAAC,MAAoB;IAC3C,OAAO,QAAQ,CAAC,MAAM,CAAC,CAAC,SAAS,EAAE,CAAC;AACtC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,QAAQ,CAAC,MAAoB;IAC3C,OAAO,QAAQ,CAAC,MAAM,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC;AACxC,CAAC"}

package/dist/projections/standard.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Standard Schema v1 — types inlined from @standard-schema/spec.
+ *
+ * We inline instead of depending on the package to keep @fougere/schema zero-dep.
+ * The spec is stable (v1) and unlikely to change.
+ *
+ * @see https://standardschema.dev/
+ */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+    readonly '~standard': StandardSchemaV1.Props<Input, Output>;
+}
+export declare namespace StandardSchemaV1 {
+    interface Props<Input = unknown, Output = Input> {
+        readonly version: 1;
+        readonly vendor: string;
+        readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+        readonly types?: Types<Input, Output> | undefined;
+    }
+    type Result<Output> = SuccessResult<Output> | FailureResult;
+    interface SuccessResult<Output> {
+        readonly value: Output;
+        readonly issues?: undefined;
+    }
+    interface FailureResult {
+        readonly issues: ReadonlyArray<Issue>;
+    }
+    interface Issue {
+        readonly message: string;
+        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+    }
+    interface PathSegment {
+        readonly key: PropertyKey;
+    }
+    interface Types<Input = unknown, Output = Input> {
+        readonly input: Input;
+        readonly output: Output;
+    }
+    type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['input'];
+    type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['output'];
+}
+//# sourceMappingURL=standard.d.ts.map

package/dist/projections/standard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard.d.ts","sourceRoot":"","sources":["../../src/projections/standard.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,WAAW,gBAAgB,CAAC,KAAK,GAAG,OAAO,EAAE,MAAM,GAAG,KAAK;IAC/D,QAAQ,CAAC,WAAW,EAAE,gBAAgB,CAAC,KAAK,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;CAC7D;AAED,MAAM,CAAC,OAAO,WAAW,gBAAgB,CAAC;IACxC,UAAU,KAAK,CAAC,KAAK,GAAG,OAAO,EAAE,MAAM,GAAG,KAAK;QAC7C,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC;QACpB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QACxB,QAAQ,CAAC,QAAQ,EAAE,CACjB,KAAK,EAAE,OAAO,KACX,MAAM,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;QAC9C,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;KACnD;IAED,KAAK,MAAM,CAAC,MAAM,IAAI,aAAa,CAAC,MAAM,CAAC,GAAG,aAAa,CAAC;IAE5D,UAAU,aAAa,CAAC,MAAM;QAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QACvB,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC;KAC7B;IAED,UAAU,aAAa;QACrB,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,KAAK,CAAC,CAAC;KACvC;IAED,UAAU,KAAK;QACb,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QACzB,QAAQ,CAAC,IAAI,CAAC,EAAE,aAAa,CAAC,WAAW,GAAG,WAAW,CAAC,GAAG,SAAS,CAAC;KACtE;IAED,UAAU,WAAW;QACnB,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC;KAC3B;IAED,UAAU,KAAK,CAAC,KAAK,GAAG,OAAO,EAAE,MAAM,GAAG,KAAK;QAC7C,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;QACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;KACzB;IAED,KAAK,UAAU,CAAC,MAAM,SAAS,gBAAgB,IAAI,WAAW,CAC5D,MAAM,CAAC,WAAW,CAAC,CAAC,OAAO,CAAC,CAC7B,CAAC,OAAO,CAAC,CAAC;IAEX,KAAK,WAAW,CAAC,MAAM,SAAS,gBAAgB,IAAI,WAAW,CAC7D,MAAM,CAAC,WAAW,CAAC,CAAC,OAAO,CAAC,CAC7B,CAAC,QAAQ,CAAC,CAAC;CACb"}

package/dist/projections/standard.js

@@ -0,0 +1,10 @@
+/**
+ * Standard Schema v1 — types inlined from @standard-schema/spec.
+ *
+ * We inline instead of depending on the package to keep @fougere/schema zero-dep.
+ * The spec is stable (v1) and unlikely to change.
+ *
+ * @see https://standardschema.dev/
+ */
+export {};
+//# sourceMappingURL=standard.js.map

package/dist/projections/standard.js.map

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

package/dist/projections/typescript.d.ts

@@ -0,0 +1,53 @@
+import type { SchemaDescriptor } from './card.js';
+export interface TypeSourceOptions {
+    /** Name of the emitted interface. Defaults to the card's `title`, capitalized. */
+    name?: string;
+    /** Emit `export` before the declaration. Default: true. */
+    exported?: boolean;
+}
+/**
+ * The anonymous object type one card describes — the members, nothing around them.
+ *
+ * Every property is present: `required` on a Fougère card answers "what must a CALLER
+ * supply at creation", not "what is always there when read" — an `id` the system
+ * generates is absent from `required` and always present on a row. Typing the read
+ * shape from the create rule would make `post.id` possibly-undefined for everyone.
+ */
+export declare function shapeTypeOf(descriptor: SchemaDescriptor, indent?: string): string;
+/**
+ * Emit the entity a card describes — ONE class, judge and shape together.
+ *
+ * An entity is a class here (`class Post extends entity({…}) {}`), and a class is the
+ * language's own answer to "a name that is both a value and a type". Emitting an
+ * interface next to a const said the same thing twice and relied on declaration
+ * merging to look like a class; this IS one.
+ *
+ * The card travels inline, so the rebuilt judge is exact — the shape written above it
+ * is read off that same card, never a second source to keep in step.
+ *
+ * Requires `reconstruct` in scope: the caller writes the import, since only it knows
+ * whether the consumer says `@fougere/schema` or a path.
+ */
+export declare function entitySourceOf(descriptor: SchemaDescriptor, options?: TypeSourceOptions): string;
+/** One operation, as much of it as a card can say. */
+export interface OpDescriptor {
+    name: string;
+    description?: string;
+    output?: SchemaDescriptor;
+    /** How much `output` describes. Absent means the card did not say. */
+    cardinality?: 'one' | 'maybe' | 'many' | 'page' | 'none';
+}
+/**
+ * Emit the type of a façade — every operation an entity serves, as a caller meets it.
+ *
+ * This is what `Facade<T>` needs and what no consumer in another repository could have:
+ * writing `Facade<ArticleHandler>` used to require importing the handler's class, which
+ * `sync` does not carry and should not. The card carries the operations; this reads them.
+ *
+ * Each op takes an optional invocation and returns a promise — the door's signature, not
+ * the handler's. A handler's method takes positional arguments; its door takes the call.
+ */
+export declare function facadeTypeSourceOf(ops: readonly OpDescriptor[], options?: TypeSourceOptions & {
+    rowType?: string;
+}): string;
+//# sourceMappingURL=typescript.d.ts.map

package/dist/projections/typescript.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typescript.d.ts","sourceRoot":"","sources":["../../src/projections/typescript.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAmB,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAwEnE,MAAM,WAAW,iBAAiB;IAChC,kFAAkF;IAClF,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,2DAA2D;IAC3D,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,UAAU,EAAE,gBAAgB,EAAE,MAAM,SAAK,GAAG,MAAM,CAS7E;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,gBAAgB,EAAE,OAAO,GAAE,iBAAsB,GAAG,MAAM,CASpG;AAmBD,sDAAsD;AACtD,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,gBAAgB,CAAC;IAC1B,sEAAsE;IACtE,WAAW,CAAC,EAAE,KAAK,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;CAC1D;AAyBD;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,SAAS,YAAY,EAAE,EAC5B,OAAO,GAAE,iBAAiB,GAAG;IAAE,OAAO,CAAC,EAAE,MAAM,CAAA;CAAO,GACrD,MAAM,CAYR"}