@drhomet/mithaq 0.0.0-stage → 0.1.1

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/zod/index.d.ts

@@ -0,0 +1,184 @@
+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>;
+    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;
+        relationship: (field: ResolvedField) => z.ZodArray<z.ZodGUID | z.ZodInt32 | z.ZodString> | z.ZodGUID | z.ZodInt32 | z.ZodString;
+        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: string | number | boolean | Date | readonly unknown[] | import("../index.ts").Ref;
+            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: typeof target & {
+    readonly derives?: ZodDerives;
+};
+export {};

package/dist/zod/index.js

@@ -0,0 +1,121 @@
+import { z } from 'zod';
+import { storedRichText } from '../rich-text/rich-text.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(),
+    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 and no `options`,
+        // so a rule or option 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, ...(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 = target;

package/dist/zod/kinds.d.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import type { ResolvedField } from '../mithaq/types.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;
+    relationship: (field: ResolvedField) => z.ZodArray<z.ZodGUID | z.ZodInt32 | z.ZodString> | z.ZodGUID | z.ZodInt32 | z.ZodString;
+    join: (field?: ResolvedField) => z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+};
+export {};

package/dist/zod/kinds.js

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import { isDecimal } from '../base/decimal.js';
+// A missing key, or a `null` on a required field, is the `required` rule refusing;
+// anything else is the kind refusing the value. A field with no kayan keeps zod's text.
+export const errorOf = (field, element = false) => field?.kayan
+    ? (issue) => issue.input === undefined || (issue.input === null && !element && field.rules?.required === true)
+        ? `${field.kayan}.${field.name}.required`
+        : `${field.kayan}.${field.name}.invalid`
+    : undefined;
+const idShapes = {
+    // A number id is an int4 `serial`, so a fraction or a value past its range is a 400, not a Postgres 500.
+    number: (error) => z.int32({ error }),
+    text: (error) => z.string({ error }),
+    // `guid`, not `uuid`: `z.uuid()` also demands an RFC version and variant, which Postgres does not.
+    uuid: (error) => z.guid({ error }),
+};
+/** The kinds this target shapes an id of, the same three the store's columns are. */
+export const idKinds = Object.keys(idShapes);
+const idShape = (kind, error) => idShapes[kind](error);
+// Narrowed to the field's `options` on the server, not only in the browser.
+const textShape = (field, element = false) => {
+    const values = field?.options?.map((option) => option.value);
+    return values?.length ? z.enum(values, { error: errorOf(field, element) }) : z.string({ error: errorOf(field, element) });
+};
+/** One shape per kind, the same record shape as the adapter's kinds. */
+export const kinds = {
+    text: textShape,
+    email: (field) => z.email({ error: errorOf(field) }),
+    // The id is the `serial` column `idShapes` says it is; any other number is a
+    // `numeric` column, which takes every finite number.
+    number: (field) => (field?.name === 'id' ? idShape('number', errorOf(field)) : z.number({ error: errorOf(field) })),
+    // A Postgres `integer`, the same int4 a number id is.
+    integer: (field) => z.int32({ error: errorOf(field) }),
+    // A JS number is refused: it may already have lost a digit. `abort`, so no
+    // rule after it reads text that is no decimal.
+    decimal: (field) => z.string({ error: errorOf(field) }).refine(isDecimal, { error: errorOf(field), abort: true }),
+    checkbox: (field) => z.boolean({ error: errorOf(field) }),
+    datetime: (field) => z.date({ error: errorOf(field) }),
+    // A string, so a `Date` is refused rather than truncated to whichever day its zone makes of it.
+    date: (field) => z.iso.date({ error: errorOf(field) }),
+    // The same error on each element, so a bad element reads as the field's own sentence.
+    textArray: (field) => z.array(textShape(field, true), { error: errorOf(field) }),
+    uuid: (field) => z.guid({ error: errorOf(field) }),
+    relationship: (field) => field.hasMany
+        ? z.array(idShape(field.target.fields.id.kind, errorOf(field, true)), { error: errorOf(field) })
+        : idShape(field.target.fields.id.kind, errorOf(field)),
+    // Left loose: the child's row shape may not be derived yet, and the child's own read already parsed the rows.
+    join: (field) => z.array(z.record(z.string(), z.unknown()), { error: errorOf(field) }),
+};

package/dist/zod/rules.d.ts

@@ -0,0 +1,117 @@
+import { z } from 'zod';
+import type { ResolvedField } from '../mithaq/types.ts';
+export declare const rules: {
+    /** The database enforces it, and only the database can. */
+    unique: ({ shape }: {
+        shape: z.ZodType;
+        value: boolean;
+        field: ResolvedField;
+    }) => z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    /** Nothing about reading rows faster changes what a write must look like. */
+    index: ({ shape }: {
+        shape: z.ZodType;
+        value: boolean;
+        field: ResolvedField;
+    }) => z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    /** A rule about deleting the other row, and a write is not a delete. */
+    onDelete: ({ shape }: {
+        shape: z.ZodType;
+        value: import("../index.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: string | number | boolean | Date | readonly unknown[] | import("../index.ts").Ref;
+        field: ResolvedField;
+    }) => z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+    /** The moment the defaults step writes, which leaves the key optional as a literal does. */
+    defaultNow: ({ shape, value: on }: {
+        shape: z.ZodType;
+        value: boolean;
+        field: ResolvedField;
+    }) => z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+    /** Filled on update by the defaults step, and never client-supplied there, so nothing to shape. */
+    nowOnUpdate: ({ shape }: {
+        shape: z.ZodType;
+        value: boolean;
+        field: ResolvedField;
+    }) => z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+};