@drhomet/mithaq 0.0.0-stage → 0.2.0

package/dist/versions/versions.js

@@ -0,0 +1,160 @@
+import { same } from '../mithaq/where.js';
+import { snakeCase, versionsTableOf } from '../mithaq/resolve.js';
+import { providerOf } from '../base/rules.js';
+import { missing } from '../asas/runner/errors.js';
+import { findVersionByID, findVersions, issueRefusal, restoreVersion } from '../asas/runner/steps.js';
+/**
+ * The `_status` field a kayan that keeps drafts spreads into its own `fields`.
+ * A plain read leaves out a row that is not `published`.
+ */
+export const draftFields = {
+    _status: {
+        kind: 'text',
+        label: { en: 'Status', ar: 'الحالة' },
+        options: [
+            { value: 'draft', label: { en: 'Draft', ar: 'مسودة' } },
+            { value: 'published', label: { en: 'Published', ar: 'منشور' } },
+        ],
+        rules: { defaultValue: 'draft', index: true },
+    },
+};
+/**
+ * The three operations a kayan that keeps versions spreads beside `defaultOperations`:
+ * `findVersions`, `findVersionByID` and `restoreVersion`.
+ */
+export const versionOperations = {
+    findVersions: { steps: [findVersions] },
+    findVersionByID: { steps: [findVersionByID] },
+    restoreVersion: { steps: [restoreVersion] },
+};
+export const versionsOf = ({ kayan, kept, name, window, }) => {
+    const where = `Kayan "${kayan.name}" writes "targets.${name}"`;
+    if (kayan.single)
+        throw new Error(`${where}, and a global keeps no versions: versions are a kayan's alone.`);
+    // A version is addressed by its own uuid, which the kayan's id shape takes only where its id is a uuid.
+    if (kayan.fields.id?.kind !== 'uuid') {
+        throw new Error(`${where}, and its id is of kind "${String(kayan.fields.id?.kind)}", while a version is addressed by a uuid. Keep the uuid id defaultFields spreads.`);
+    }
+    if (kept.drafts && !kayan.fields._status) {
+        throw new Error(`${where} with drafts, and declares no field "_status", which is where a row says whether it is a draft or published. Spread draftFields into its fields.`);
+    }
+    const max = kept.max ?? window;
+    if (!Number.isInteger(max) || max < 0)
+        throw new Error(`${where} with max ${String(max)}, and max is a whole number of versions, 0 keeping every one.`);
+    const interval = typeof kept.drafts === 'object' && typeof kept.drafts.autosave === 'object' ? kept.drafts.autosave.interval : 2000;
+    if (!Number.isInteger(interval) || interval <= 0)
+        throw new Error(`${where} with an autosave interval of ${String(interval)}, and an interval is a whole number of milliseconds above 0.`);
+    const table = versionsTableOf(kayan);
+    const column = (field, kind, named = snakeCase(field)) => ({ name: field, kind, column: named, kayan: table });
+    return {
+        table,
+        drafts: !!kept.drafts,
+        autosave: typeof kept.drafts === 'object' && kept.drafts.autosave ? { interval } : false,
+        max,
+        kayan: {
+            name: table,
+            table,
+            ...(kayan.schemaName !== undefined && { schemaName: kayan.schemaName }),
+            store: kayan.store,
+            schema: kayan.schema,
+            operations: {},
+            indexes: [],
+            // No prototype, so a query naming `toString` finds no field rather than a function.
+            fields: Object.assign(Object.create(null), {
+                id: column('id', 'uuid'),
+                parent: { ...column('parent', kayan.fields.id.kind, 'parent_id'), target: kayan },
+                latest: column('latest', 'checkbox'),
+                autosave: column('autosave', 'checkbox'),
+                createdAt: column('createdAt', 'datetime'),
+                updatedAt: column('updatedAt', 'datetime'),
+            }),
+        },
+    };
+};
+const newest = { field: 'updatedAt', direction: 'desc' };
+// jsonb holds a moment as its ISO string, so each datetime field becomes a `Date` again.
+export const revived = (kayan, snapshot) => {
+    const row = { ...snapshot };
+    const moment = (held) => (typeof held === 'string' ? new Date(held) : held);
+    for (const field of Object.values(kayan.fields)) {
+        const held = row[field.name];
+        if (field.kind !== 'datetime' || held === null || held === undefined)
+            continue;
+        row[field.name] = typeof held === 'object' && !(held instanceof Date)
+            ? Object.fromEntries(Object.entries(held).map(([locale, one]) => [locale, moment(one)]))
+            : moment(held);
+    }
+    return row;
+};
+export const latestVersion = async ({ kayan, store, parent, tx, }) => (await store.find({ kayan: kayan.versions.table, args: {
+        limit: 1,
+        page: 1,
+        sort: newest,
+        where: { and: [{ parent: { equals: parent } }, { latest: { equals: true } }] },
+    }, tx })).docs[0];
+// In the write's own transaction, so the audit step after it covers it. An
+// autosave overwrites the latest version only where that one is an autosave.
+export const saveVersion = async ({ kayan, store, writes, tx, row, autosave, }) => {
+    const { table, max } = kayan.versions;
+    const latest = await latestVersion({ kayan, store, parent: row.id, tx });
+    // A row's version moments only rise: two saves in one millisecond would let the
+    // previous-version read skip one and leave the order to the random ids.
+    const now = new Date(Math.max(Date.now(), latest ? new Date(latest.updatedAt).getTime() + 1 : 0));
+    if (autosave && latest?.autosave === true) {
+        await writes.update({ tx, kayan: table, id: latest.id, data: { version: row, updatedAt: now } });
+        return;
+    }
+    if (latest)
+        await writes.update({ tx, kayan: table, id: latest.id, data: { latest: false } });
+    await writes.insert({ tx, kayan: table, data: { parent: row.id, version: row, latest: true, autosave, createdAt: now, updatedAt: now } });
+    if (max < 1)
+        return;
+    // Never the one just inserted: two saves in one write can share a millisecond.
+    const older = { and: [{ parent: { equals: row.id } }, { latest: { equals: false } }] };
+    const past = await store.find({ kayan: table, args: { ...(max > 1 ? { limit: max - 1, page: 2 } : { limit: 0, page: 1 }), sort: newest, where: older }, tx });
+    for (const old of past.docs)
+        await writes.remove({ tx, kayan: table, id: old.id });
+};
+// `_status` is left out because the write decides it: the row always holds the
+// last published copy, so a restore that writes the row publishes it.
+export const changedColumns = ({ kayan, snapshot, row, whole = false, }) => Object.fromEntries(Object.values(kayan.fields)
+    .filter((field) => field.name !== 'id' && field.name !== '_status' && field.kind !== 'join' &&
+    providerOf(field, 'update') === 'client' && field.name in snapshot &&
+    ((whole && snapshot[field.name] != null && !same(snapshot[field.name], [])) || !same(snapshot[field.name], row[field.name])))
+    .map((field) => [field.name, snapshot[field.name] ?? null]));
+// The row's read access comes first, so nothing about a row the actor cannot
+// read is told: such a version is refused in the words an absent one is.
+export const restoreInput = async ({ kayan, store, data, actor, authorize, admin, alive, seesDrafts, admits, }) => {
+    const absent = () => missing({
+        message: `No "${kayan.name}" version with id ${String(data.id)} to restore.`,
+        key: 'error.not_found.row',
+        params: { kayan: kayan.name, id: data.id, operation: 'restoreVersion' },
+    });
+    // Nothing has parsed a version id yet, and it is the versions table's own uuid whatever the row's id is.
+    if (typeof data.id !== 'string' || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(data.id)) {
+        throw issueRefusal([{ message: 'Invalid UUID', path: ['id'] }], 'mithaq');
+    }
+    // A restore may publish a draft nothing else shows this actor, so it asks the
+    // key a draft read asks; without it the id answers as absent.
+    if (!seesDrafts)
+        throw absent();
+    const [version] = (await store.find({ kayan: kayan.versions.table, args: { limit: 1, page: 1, sort: newest, where: { id: { equals: data.id } } } })).docs;
+    // No version has that id, so it may name a published row whose pending draft is
+    // being discarded: restoring the row onto itself publishes the last published copy.
+    const parent = version ? version.parent : data.id;
+    // Asked with no operation, so no key but the restore's own is asked for.
+    const rowOf = async (id, admitted) => {
+        const readable = await authorize({ admin, actor, data: { id }, effect: 'read', kayan });
+        const scoped = [{ id: { equals: id } }, readable, alive, admitted].filter(Boolean);
+        return (await store.find({ kayan: kayan.name, args: { limit: 1, page: 1, sort: { field: 'id', direction: 'asc' }, where: { and: scoped } } })).docs[0];
+    };
+    // Version and row ids share one uuid space, and a caller may choose a row's id,
+    // so an id that also names a row the actor sees is the row's. Looked for in the
+    // actor's scope only, or another tenant could block restores with a learned id.
+    if (version && await rowOf(data.id))
+        throw absent();
+    const row = await rowOf(parent, admits);
+    if (!row || (!version && row._status !== 'published'))
+        throw absent();
+    return { ...(version && changedColumns({ kayan, snapshot: revived(kayan, version.version), row, whole: kayan.versions.drafts && row._status !== 'published' })), id: parent };
+};

package/dist/vite.d.ts

@@ -0,0 +1,7 @@
+import { type Plugin } from 'vite';
+/**
+ * Serves the admin's pieces from the installed `mithaq-admin`, and a file the project ejected into `ejected`
+ * in place of the package's file of the same name, for every importer: the app, the package's own pieces and
+ * other ejected files. Deleting the ejected file returns the project to the package's.
+ */
+export declare const mithaqAdmin: (ejected: string) => Plugin;

package/dist/vite.js

@@ -0,0 +1,81 @@
+import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
+import { normalizePath } from 'vite';
+/**
+ * Serves the admin's pieces from the installed `mithaq-admin`, and a file the project ejected into `ejected`
+ * in place of the package's file of the same name, for every importer: the app, the package's own pieces and
+ * other ejected files. Deleting the ejected file returns the project to the package's.
+ */
+export const mithaqAdmin = (ejected) => {
+    // Resolved from the project, so a store layout finds the copy the project installed.
+    const registry = join(dirname(createRequire(join(ejected, 'x')).resolve('mithaq-admin/package.json')), 'registry/');
+    return {
+        name: 'mithaq-admin',
+        enforce: 'pre',
+        // Pre-bundled, a piece the app imports and the same piece a sibling imports are two modules in dev.
+        // No `server.warmup` of the package: measured cold, it served the first page 0.7 s later and loaded the
+        // client 1 s sooner, and it set the optimizer discovering dependencies no page asked for yet.
+        config: () => ({ optimizeDeps: { exclude: ['mithaq-admin'] } }),
+        // The dependency scan stops at the excluded package, so what only the pieces import (Lexical, TanStack Form, and
+        // through the app's own primitives, Base UI) would be found by the first page that needs it, re-optimized mid-page
+        // into a second React, and the page reloaded. Named up front instead, but only what the project installed from a
+        // registry: an optional peer it left out (Lexical without rich text) fails the whole optimization, and a linked
+        // workspace package is served as source, where an include would stop the scan finding what it imports. And only
+        // what nothing excludes, since an include wins over an exclude: last, after every plugin has named its own.
+        configEnvironment: { order: 'post', handler(name, { optimizeDeps, resolve }) {
+                if (name !== 'client')
+                    return;
+                // ponytail: an exclude a plugin adds later than configEnvironment (in configResolved) is not seen here and loses
+                // to the include; read the resolved config there if a plugin ever does.
+                const excluded = optimizeDeps?.exclude ?? [];
+                const folders = createRequire(join(ejected, 'x')).resolve.paths('x') ?? [];
+                const alias = resolve?.alias ?? [];
+                const aliases = Array.isArray(alias) ? alias : Object.entries(alias).map(([find, replacement]) => ({ find, replacement }));
+                /** The file of the app's a relative or aliased specifier names, '' where none is, or nothing for a package. */
+                const local = (specifier, from) => {
+                    const entry = aliases.find(({ find }) => (typeof find === 'string' ? specifier === find || specifier.startsWith(`${find}/`) : find.test(specifier)));
+                    const path = specifier.startsWith('.') ? join(dirname(from), specifier) : entry && specifier.replace(entry.find, entry.replacement);
+                    return path === undefined ? undefined : (['', '.tsx', '.ts'].map((extension) => path + extension).find((file) => statSync(file, { throwIfNoEntry: false })?.isFile()) ?? '');
+                };
+                // The pieces, and the app's own files they reach, such as the primitives the published package leaves out.
+                // What a project ejects into its language package (mail, steps, storage) runs on the server alone.
+                const files = new Set(readdirSync(registry, { recursive: true, encoding: 'utf8' }).filter((file) => /\.tsx?$/.test(file) && !/^(mail|steps|storage)\//.test(normalizePath(file))).map((file) => join(registry, file)));
+                const imports = new Set();
+                for (const file of files) {
+                    // ponytail: a regex over the source, which a ` from '...'` inside a string or a comment fools into one more
+                    // include; parse the files if a piece ever reads that way.
+                    for (const [, type, specifier] of readFileSync(file, 'utf8').matchAll(/^(?:import|export)\s+(type\s)?(?:[^'";]*?\sfrom\s*)?['"]([^'"]+)['"]/gm)) {
+                        if (type)
+                            continue;
+                        const found = local(specifier, file);
+                        if (found)
+                            files.add(found);
+                        else if (found === undefined)
+                            imports.add(specifier);
+                    }
+                }
+                const include = [...imports].filter((specifier) => {
+                    // `mithaq` too, which the app's own code imports, so the scan finds it: named here, its rich text would be
+                    // bundled where no Lexical is installed.
+                    if (/^(\/|node:|mithaq(\/|$))/.test(specifier))
+                        return false;
+                    const pkg = specifier.split('/').slice(0, specifier.startsWith('@') ? 2 : 1).join('/');
+                    const installed = folders.map((folder) => join(folder, pkg)).find((folder) => existsSync(join(folder, 'package.json')));
+                    return !excluded.includes(pkg) && !excluded.includes(specifier) && !!installed && normalizePath(realpathSync(installed)).includes('/node_modules/');
+                });
+                return { optimizeDeps: { include: include.sort() } };
+            } },
+        // By the specifier, not by resolving it: published as `@drhomet/mithaq-admin`, a piece in a store's folder cannot
+        // reach `mithaq-admin/<file>` by walking up, so the plugin answers for every importer.
+        resolveId(source) {
+            const [, file] = /^mithaq-admin\/(.+\.tsx?)$/.exec(source) ?? [];
+            // A piece names a sibling by its file alone, so a climb out of the package is no import of ours.
+            if (!file || file.split('/').includes('..'))
+                return;
+            const own = join(ejected, file);
+            // The real path, as Vite names every other module, so a symlinked folder is never a second module.
+            return normalizePath(existsSync(own) ? realpathSync(own) : join(registry, file));
+        },
+    };
+};

package/dist/zod/index.d.ts

@@ -0,0 +1,193 @@
+import { z } from 'zod';
+import type { ResolvedField, RuntimeField } from '../mithaq/types.ts';
+import type { Derives, FieldsOf } from '../asas/runner/steps.ts';
+import type { CreateOf, IdOf, RowOf, UpdateOf } from '../asas/runner/write.ts';
+export type ZodShape = (field: ResolvedField) => z.ZodType;
+export type ZodRule<Value = never> = (args: {
+    shape: z.ZodType;
+    value: Value;
+    field: ResolvedField;
+}) => z.ZodType;
+type ZodTyped<Value> = z.ZodType<Value, Value>;
+type ZodColumn<Value> = undefined extends Value ? z.ZodOptional<ZodTyped<Exclude<Value, undefined>>> : ZodTyped<Value>;
+type ZodDerived<Shape, Config extends z.core.$ZodObjectConfig> = z.ZodObject<{
+    [Key in keyof Shape]-?: ZodColumn<Shape[Key]>;
+}, Config>;
+type ZodShapes<F extends Record<string, RuntimeField>> = {
+    create: ZodDerived<CreateOf<F, 'zod'>, z.core.$strict>;
+    update: ZodDerived<UpdateOf<F, 'zod'>, z.core.$strict>;
+    id: ZodDerived<IdOf<F, 'zod'>, z.core.$strict>;
+    byID: z.ZodObject<ZodDerived<IdOf<F, 'zod'>, z.core.$strict>['shape'] & {
+        depth: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strict>;
+    row: ZodDerived<RowOf<F, 'zod'>, z.core.$strip>;
+    list: typeof listShape;
+    draft: z.ZodObject<{
+        [Key in keyof RowOf<F, 'zod'>]-?: z.ZodOptional<z.ZodNullable<ZodTyped<RowOf<F, 'zod'>[Key]>>>;
+    }, z.core.$strip>;
+    draftWrite: z.ZodObject<{
+        [Key in keyof RowOf<F, 'zod'>]-?: z.ZodOptional<z.ZodNullable<ZodTyped<RowOf<F, 'zod'>[Key]>>>;
+    }, z.core.$strip>;
+};
+declare const listShape: z.ZodObject<{
+    data: z.ZodOptional<z.ZodUnknown>;
+    depth: z.ZodOptional<z.ZodUnknown>;
+    for: z.ZodOptional<z.ZodUnknown>;
+    limit: z.ZodOptional<z.ZodUnknown>;
+    page: z.ZodOptional<z.ZodUnknown>;
+    sort: z.ZodOptional<z.ZodUnknown>;
+    where: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strict>;
+interface ZodDerives extends Derives {
+    readonly shapes: ZodShapes<FieldsOf<this>>;
+}
+declare const target: {
+    readonly capability: 'schema';
+    readonly type: 'zod';
+    readonly idKinds: ("number" | "text" | "uuid")[];
+    readonly kinds: {
+        text: (field?: ResolvedField, element?: boolean) => z.ZodEnum<{
+            [x: string]: string;
+        }> | z.ZodString;
+        email: (field?: ResolvedField) => z.ZodEmail;
+        number: (field?: ResolvedField) => z.ZodGUID | z.ZodNumber | z.ZodString;
+        integer: (field?: ResolvedField) => z.ZodInt32;
+        decimal: (field?: ResolvedField) => z.ZodString & z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+        checkbox: (field?: ResolvedField) => z.ZodBoolean;
+        datetime: (field?: ResolvedField) => z.ZodDate;
+        date: (field?: ResolvedField) => z.ZodISODate;
+        textArray: (field?: ResolvedField) => z.ZodArray<z.ZodEnum<{
+            [x: string]: string;
+        }> | z.ZodString>;
+        uuid: (field?: ResolvedField) => z.ZodGUID | z.ZodInt32 | z.ZodString;
+        relationship: (field: ResolvedField) => z.ZodArray<z.ZodGUID | z.ZodInt32 | z.ZodString> | z.ZodGUID | z.ZodInt32 | z.ZodString;
+        json: (field?: ResolvedField) => z.ZodCustom<import("../base/kinds.ts").Json, import("../base/kinds.ts").Json>;
+        join: (field?: ResolvedField) => z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    };
+    readonly rules: {
+        unique: ({ shape }: {
+            shape: z.ZodType;
+            value: boolean;
+            field: ResolvedField;
+        }) => z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        index: ({ shape }: {
+            shape: z.ZodType;
+            value: boolean;
+            field: ResolvedField;
+        }) => z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        onDelete: ({ shape }: {
+            shape: z.ZodType;
+            value: import("../base/kinds.ts").OnDelete;
+            field: ResolvedField;
+        }) => z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        providedBy: ({ shape }: {
+            shape: z.ZodType;
+            value: Readonly<{
+                create?: import("../base/rules.ts").Provider;
+                update?: import("../base/rules.ts").Provider;
+            }>;
+            field: ResolvedField;
+        }) => z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        minLength: ({ shape, value: length, field }: {
+            shape: z.ZodType;
+            value: number;
+            field: ResolvedField;
+        }) => z.ZodString;
+        maxLength: ({ shape, value: length, field }: {
+            shape: z.ZodType;
+            value: number;
+            field: ResolvedField;
+        }) => z.ZodString;
+        pattern: ({ shape, value: expression, field }: {
+            shape: z.ZodType;
+            value: RegExp;
+            field: ResolvedField;
+        }) => z.ZodString;
+        precision: ({ shape, value: precision, field }: {
+            shape: z.ZodType;
+            value: number;
+            field: ResolvedField;
+        }) => z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        scale: ({ shape, value: scale, field }: {
+            shape: z.ZodType;
+            value: number;
+            field: ResolvedField;
+        }) => z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        min: ({ shape, value, field }: {
+            shape: z.ZodType;
+            value: string | number;
+            field: ResolvedField;
+        }) => z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        max: ({ shape, value, field }: {
+            shape: z.ZodType;
+            value: string | number;
+            field: ResolvedField;
+        }) => z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        minRows: ({ shape, value: rows, field }: {
+            shape: z.ZodType;
+            value: number;
+            field: ResolvedField;
+        }) => z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        maxRows: ({ shape, value: rows, field }: {
+            shape: z.ZodType;
+            value: number;
+            field: ResolvedField;
+        }) => z.ZodArray<z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        trim: ({ shape, value: on, field }: {
+            shape: z.ZodType;
+            value: boolean;
+            field: ResolvedField;
+        }) => z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        uppercase: ({ shape, value: on, field }: {
+            shape: z.ZodType;
+            value: boolean;
+            field: ResolvedField;
+        }) => z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        lowercase: ({ shape, value: on, field }: {
+            shape: z.ZodType;
+            value: boolean;
+            field: ResolvedField;
+        }) => z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        localized: ({ shape, value: on, field }: {
+            shape: z.ZodType;
+            value: boolean;
+            field: ResolvedField;
+        }) => z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        required: ({ shape, value: on, field }: {
+            shape: z.ZodType;
+            value: boolean;
+            field: ResolvedField;
+        }) => z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        defaultValue: ({ shape }: {
+            shape: z.ZodType;
+            value: Date | readonly unknown[] | import("../index.ts").Ref | import("../base/kinds.ts").Json;
+            field: ResolvedField;
+        }) => z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        defaultNow: ({ shape, value: on }: {
+            shape: z.ZodType;
+            value: boolean;
+            field: ResolvedField;
+        }) => z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        nowOnUpdate: ({ shape }: {
+            shape: z.ZodType;
+            value: boolean;
+            field: ResolvedField;
+        }) => z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    };
+    readonly derive: <F extends Record<string, ResolvedField>>(this: {
+        kinds: Record<string, ZodShape>;
+        rules: Record<string, ZodRule>;
+    }, fields: F) => ZodShapes<F>;
+};
+/** The zod schema target. */
+export declare const zodTarget: <const Kinds extends Record<string, ZodShape>, const Rules extends Record<string, ZodRule>, const IdKinds extends readonly string[]>({ kinds, rules, idKinds }: {
+    kinds: Kinds;
+    rules: Rules;
+    idKinds: IdKinds;
+}) => Omit<typeof target, 'kinds' | 'rules' | 'idKinds'> & {
+    kinds: Kinds;
+    rules: Rules;
+    idKinds: IdKinds;
+    readonly derives?: ZodDerives;
+};
+export {};

package/dist/zod/index.js

@@ -0,0 +1,122 @@
+import { z } from 'zod';
+import { storedRichText } from '../rich-text/value.js';
+import { providerOf } from '../base/rules.js';
+import { idKinds as zodIdKinds, kinds as zodKinds } from './kinds.js';
+import { implementationOf } from '../mithaq/rukn.js';
+import { rules as zodRules } from './rules.js';
+// Every rule is applied here and nowhere else. A field's `targets.zod` is its
+// whole shape, rules skipped.
+const fieldShapes = (fields, shapes, rules) => Object.fromEntries(Object.values(fields).map((field) => {
+    const override = (field.schemaTarget && field.targets?.[field.schemaTarget]);
+    if (override)
+        return [field.name, override];
+    // The project's own entry, then the kind's own, then the shipped table.
+    let shape = implementationOf({ table: shapes, shipped: zodKinds, name: field.kind, own: field.kindTargets, type: 'zod' })(field);
+    const fieldRules = field.rules ?? {};
+    for (const rule of Object.keys(rules)) {
+        if (rule in fieldRules) {
+            shape = rules[rule]({ shape, value: fieldRules[rule], field });
+        }
+    }
+    // An id is filled by the database or by whoever owns the table, so a write never has to carry one.
+    return [field.name, field.name === 'id' ? shape.optional() : shape];
+}));
+// Strict, so an unknown key is refused at the boundary rather than stripped.
+const kayanSchema = (built) => z.strictObject(built);
+// A field the client does not supply is absent, not optional, so the strict
+// object refuses a caller that sends it rather than discarding the value.
+const supplied = (built, fields, on) => Object.fromEntries(Object.values(fields)
+    .filter((field) => field.name === 'id' || providerOf(field, on) === 'client')
+    .map((field) => [field.name, built[field.name]]));
+const outputShape = (shape) => {
+    const hasTransform = (value, seen = new WeakSet()) => {
+        if (!value || typeof value !== 'object' || seen.has(value))
+            return false;
+        seen.add(value);
+        if (value instanceof z.ZodType) {
+            const definition = value._def;
+            if (definition?.type === 'transform')
+                return true;
+            return hasTransform(definition, seen);
+        }
+        if (Array.isArray(value))
+            return value.some((one) => hasTransform(one, seen));
+        return Object.values(value).some((one) => hasTransform(one, seen));
+    };
+    const definition = shape._def;
+    if (definition?.type === 'optional' && definition.innerType)
+        return outputShape(definition.innerType);
+    if (definition?.type === 'nullable' && definition.innerType) {
+        return outputShape(definition.innerType).nullable();
+    }
+    if (['catch', 'default'].includes(String(definition?.type)) && definition?.innerType) {
+        return outputShape(definition.innerType);
+    }
+    if (definition?.type === 'pipe' && definition.out)
+        return outputShape(definition.out);
+    if (hasTransform(shape)) {
+        throw new Error('A zod transform override needs an output schema: use `.pipe(schema)`.');
+    }
+    return shape;
+};
+// A `join` is optional rather than nullable: a read with no depth hands back no
+// value for it, and a nullable key would demand an explicit `null`.
+const rowSchema = (schema, fields) => z.object(Object.fromEntries(Object.entries(schema.shape).map(([name, shape]) => [
+    name,
+    (() => {
+        const required = outputShape(shape);
+        if (fields[name]?.kind === 'join')
+            return required.optional();
+        return name === 'id' || fields[name]?.rules?.required ? required : required.nullable();
+    })(),
+])));
+// Strict: a misspelled `wher` stripped would answer every row unfiltered.
+const listShape = z.strictObject({
+    data: z.unknown().optional(),
+    depth: z.unknown().optional(),
+    for: z.unknown().optional(),
+    limit: z.unknown().optional(),
+    page: z.unknown().optional(),
+    sort: z.unknown().optional(),
+    where: z.unknown().optional(),
+});
+// The cast puts the mapped return type on: nothing inside can prove what `ZodDerives` states.
+const target = {
+    capability: 'schema',
+    type: 'zod',
+    idKinds: zodIdKinds,
+    kinds: zodKinds,
+    rules: zodRules,
+    derive(fields) {
+        const built = fieldShapes(fields, this.kinds, this.rules);
+        // A stored row is read against its kinds alone, with no rule, `options`, `jsonSchema` or `maxBytes`,
+        // so one added after rows were stored refuses their next save, never their read.
+        const kinds = Object.fromEntries(Object.entries(fields).map(([name, field]) => [
+            name,
+            { ...field, options: undefined, jsonSchema: undefined, maxBytes: undefined, ...(field.kind === 'richText' && { richText: storedRichText }) },
+        ]));
+        const stored = fieldShapes(kinds, this.kinds, { localized: this.rules.localized });
+        const drafted = fieldShapes(Object.fromEntries(Object.entries(kinds).map(([name, field]) => [name, field.kind === 'richText' ? { ...field, richText: fields[name].richText, rules: { ...field.rules, required: false } } : field])), this.kinds, { localized: this.rules.localized });
+        const create = kayanSchema(supplied(built, fields, 'create'));
+        const changeable = kayanSchema(supplied(built, fields, 'update'));
+        const update = 'id' in fields ? changeable.partial().required({ id: true }) : changeable.partial();
+        // `pick` keeps the strict object strict, so every other key is refused.
+        const id = 'id' in fields ? update.pick({ id: true }) : z.strictObject({});
+        return {
+            create,
+            update,
+            id,
+            byID: id.extend({ depth: z.unknown().optional() }),
+            // Built from every field: a row is what the store holds, not what a caller may send.
+            row: rowSchema(kayanSchema(stored), fields),
+            list: listShape,
+            // Stripped rather than strict: the runner has already refused unknown keys, and
+            // a version stored before a field was dropped still reads.
+            draft: z.object(Object.fromEntries(Object.entries(stored).map(([name, shape]) => [name, shape.nullable().optional()]))),
+            // A draft may leave out what `required` asks for, but its rich text is still checked.
+            draftWrite: z.object(Object.fromEntries(Object.entries(drafted).map(([name, shape]) => [name, shape.nullable().optional()]))),
+        };
+    },
+};
+/** The zod schema target. */
+export const zodTarget = ({ kinds, rules, idKinds }) => ({ ...target, kinds, rules, idKinds });

package/dist/zod/kinds.d.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import type { ResolvedField } from '../mithaq/types.ts';
+import { type Json } from '../base/kinds.ts';
+export declare const errorOf: (field?: ResolvedField, element?: boolean) => ((issue: {
+    input: unknown;
+}) => string) | undefined;
+type KindError = ReturnType<typeof errorOf>;
+declare const idShapes: {
+    number: (error?: KindError) => z.ZodInt32;
+    text: (error?: KindError) => z.ZodString;
+    uuid: (error?: KindError) => z.ZodGUID;
+};
+/** The kinds this target shapes an id of, the same three the store's columns are. */
+export declare const idKinds: (keyof typeof idShapes)[];
+declare const textShape: (field?: ResolvedField, element?: boolean) => z.ZodEnum<{
+    [x: string]: string;
+}> | z.ZodString;
+/** One shape per kind, the same record shape as the adapter's kinds. */
+export declare const kinds: {
+    text: typeof textShape;
+    email: (field?: ResolvedField) => z.ZodEmail;
+    number: (field?: ResolvedField) => z.ZodGUID | z.ZodNumber | z.ZodString;
+    integer: (field?: ResolvedField) => z.ZodInt32;
+    decimal: (field?: ResolvedField) => z.ZodString & z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+    checkbox: (field?: ResolvedField) => z.ZodBoolean;
+    datetime: (field?: ResolvedField) => z.ZodDate;
+    date: (field?: ResolvedField) => z.ZodISODate;
+    textArray: (field?: ResolvedField) => z.ZodArray<z.ZodEnum<{
+        [x: string]: string;
+    }> | z.ZodString>;
+    uuid: (field?: ResolvedField) => z.ZodGUID | z.ZodInt32 | z.ZodString;
+    relationship: (field: ResolvedField) => z.ZodArray<z.ZodGUID | z.ZodInt32 | z.ZodString> | z.ZodGUID | z.ZodInt32 | z.ZodString;
+    json: (field?: ResolvedField) => z.ZodCustom<Json, Json>;
+    join: (field?: ResolvedField) => z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+};
+export {};