@drhomet/mithaq 0.1.1 → 0.2.0

package/dist/auth/better-auth/generate.js

@@ -42,6 +42,9 @@ const fieldSource = (name, field) => {
     const keys = [
         field.required ? 'required: true' : '',
         field.unique ? 'unique: true' : '',
+        // Better Auth's own migrations build it, so leaving it out would have the next migrate drop it.
+        // A unique column's constraint is already its index.
+        field.index && !field.unique ? 'index: true' : '',
         field.onUpdate && field.type === 'date' ? 'nowOnUpdate: true' : '',
         field.onUpdate ? "providedBy: { update: 'application' }" : '',
     ];
@@ -60,7 +63,7 @@ const fieldSource = (name, field) => {
     const named = dbName === snakeCase(fieldName) ? '' : `, dbName: ${sourceString(dbName)}`;
     return `  ${sourceKey(fieldName)}: { kind: '${kind}'${named}${rules ? `, rules: { ${rules} }` : ''} },`;
 };
-const kayanSource = ({ name, table, provider, providers, screens = {}, access = false, drawn, schemaName, idKind, }) => {
+const kayanSource = ({ name, table, language, provider, providers, screens = {}, access = false, operations = false, drawn, schemaName, idKind, }) => {
     const exported = exportName(name);
     // Written only under screens that list the kayan: a `targets.<screen>` on a kayan
     // the screen does not list is refused at build.
@@ -82,14 +85,16 @@ const kayanSource = ({ name, table, provider, providers, screens = {}, access =
     const key = identifier.test(provider ?? '') ? `.${provider}` : `[${sourceString(provider ?? '')}]`;
     const imports = [
         `import { betterAuth, defaultFields, defaultOperations } from 'mithaq'`,
-        `import { defineKayan } from '../../../mithaq.ts'`,
+        `import { defineKayan } from ${sourceString(language)}`,
         ...(carries ? [`import { providers } from ${sourceString(providers ?? '')}`] : []),
         ...references.map((model) => `import { ${exportName(model)} } from './${exportName(model)}.ts'`),
         ...(access ? [`import { access } from './${exported}.access.ts'`] : []),
+        ...(operations ? [`import { operations } from './${exported}.operations.ts'`] : []),
         ...(drawn ? [`import { screens } from './${exported}.screens.ts'`] : []),
     ];
     if (!carries)
         imports[0] = `import { defaultFields, defaultOperations } from 'mithaq'`;
+    const operationSource = operations ? '{ ...defaultOperations, ...operations }' : 'defaultOperations';
     return `${header}
 // This kayan's access and what each screen draws of it are the project's:
 // \`${exported}.access.ts\` exporting \`access\` and \`${exported}.screens.ts\` exporting
@@ -102,7 +107,7 @@ export const ${exported} = defineKayan({
   dbName: ${sourceString(dbName)}`},${schemaName === undefined ? '' : `
   schemaName: ${sourceString(schemaName)},`}${carries ? `
   auth: betterAuth({ server: providers${key}.server }),` : ''}
-  targets: { ${drawn ? `${titled.slice(2)}${titled ? ', ' : ''}...screens, service: { operations: defaultOperations }` : `service: { operations: defaultOperations }${titled}`} },${access ? `
+  targets: { ${drawn ? `${titled.slice(2)}${titled ? ', ' : ''}...screens, service: { operations: ${operationSource} }` : `service: { operations: ${operationSource} }${titled}`} },${access ? `
   access,` : ''}
   fields: {
     ...defaultFields,
@@ -157,7 +162,7 @@ ${[...groups].map(([key, list]) => `  ${sourceKey(key)}: [${list.join(', ')}],`)
  * Writes one kayan file per Better Auth table, and one barrel beside them. With `check`, writes
  * nothing and returns the files a run would change or delete. A file without the header is never touched.
  */
-export const generateAuth = async ({ options, directory, check = false, provider, providers, screens, schemaName, }) => {
+export const generateAuth = async ({ options, directory, language, check = false, provider, providers, screens, schemaName, }) => {
     const tables = getAuthTables(options);
     const names = Object.keys(tables);
     // With a `uuid` id, Better Auth's pg adapter leaves the id out of the insert and the
@@ -171,9 +176,9 @@ export const generateAuth = async ({ options, directory, check = false, provider
     if (!check)
         await mkdir(directory, { recursive: true });
     const files = (await readFolder(directory)).map((entry) => entry.name);
-    // A sibling `<kayan>.access.ts` or `<kayan>.screens.ts` is the only way in: the
+    // Sibling access, screens and operations files are the project's way in: the
     // generated file is the generator's.
-    const siblings = new Set(files.filter((file) => file.endsWith('.access.ts') || file.endsWith('.screens.ts')));
+    const siblings = new Set(files.filter((file) => file.endsWith('.access.ts') || file.endsWith('.screens.ts') || file.endsWith('.operations.ts')));
     // Read by importing it: a title written beside a block the sibling also writes is
     // one the compiler refuses as overwritten.
     const drawnBy = new Map();
@@ -185,7 +190,7 @@ export const generateAuth = async ({ options, directory, check = false, provider
     }
     const wanted = new Map(Object.entries(tables).map(([name, table]) => [
         `${name}.ts`,
-        kayanSource({ name, table: table, provider, providers, screens, access: siblings.has(`${name}.access.ts`), drawn: drawnBy.get(`${name}.screens.ts`), schemaName, idKind }),
+        kayanSource({ name, table: table, language, provider, providers, screens, access: siblings.has(`${name}.access.ts`), operations: siblings.has(`${name}.operations.ts`), drawn: drawnBy.get(`${name}.screens.ts`), schemaName, idKind }),
     ]));
     // Otherwise the `auth` key would be written onto nothing.
     const named = Object.entries(tables).some(([name, table]) => (table.modelName ?? name) === provider);
@@ -253,6 +258,19 @@ export const run = async (project, check) => {
             throw error;
         throw new Refusal(`\`generate.providers\` names "${from}", which cannot be found from a generated file under ${sourceString(folder)}. Name a package this project depends on, or a path relative to a generated file.`);
     }
+    // The language sits wherever the project's layout puts it, a package or a file, so nothing stands in for it either.
+    const language = generate?.language;
+    if (typeof language !== 'string') {
+        throw new Refusal(`src/mithaq.ts names no \`generate.language\`, which is the module each generated kayan imports \`defineKayan\` from. Add \`language: '<package name, or a path relative to a generated file>'\` to \`generate\`, beside \`auth: ${sourceString(folder)}\`.`);
+    }
+    try {
+        createRequire(new URL('instance/index.ts', root)).resolve(language);
+    }
+    catch (error) {
+        if (error.code !== 'MODULE_NOT_FOUND')
+            throw error;
+        throw new Refusal(`\`generate.language\` names "${language}", which cannot be found from a generated file under ${sourceString(folder)}. Name the language's package, or a path relative to a generated file.`);
+    }
     const { providers } = (await import(__rewriteRelativeImportExtension(pathToFileURL(resolved).href)));
     if (!providers) {
         throw new Refusal(`${from} exports no \`providers\`, which is the record this generator reads: one key per kayan a Better Auth instance authenticates, each \`{ options, server }\`.`);
@@ -274,7 +292,7 @@ export const run = async (project, check) => {
     const changed = [];
     for (const [provider, one] of Object.entries(providers)) {
         const schemaName = one.schemaName;
-        const files = await generateAuth({ options: one.options, directory: new URL(`${provider}/`, root), check, provider, providers: from, screens, schemaName });
+        const files = await generateAuth({ options: one.options, directory: new URL(`${provider}/`, root), language, check, provider, providers: from, screens, schemaName });
         changed.push(...files.map((file) => `${provider}/${file}`));
     }
     // A directory of an instance no longer declared is reported, never removed: the

package/dist/auth/better-auth/index.d.ts

@@ -81,12 +81,14 @@ export declare const betterAuth: <Server extends BetterAuth, Targets = unknown>(
     server: (targets: Targets, vocabulary: {
         catalog: readonly string[];
         statements: Readonly<Record<string, readonly string[]>>;
+        referenced: (id: string) => Promise<number>;
     }) => Server;
 }) => {
     provider: 'better-auth';
     server: (targets: Targets, vocabulary: {
         catalog: readonly string[];
         statements: Readonly<Record<string, readonly string[]>>;
+        referenced: (id: string) => Promise<number>;
     }) => Server;
 };
 export {};

package/dist/auth/better-auth/tenant.d.ts

@@ -3,16 +3,24 @@ import type { TenantTarget } from '../../mithaq/language.ts';
  * The tenant target over Better Auth's organizations, laid down under `targets.tenant`.
  * A tenant-owned kayan places its field, `organizationId: tenant.field`.
  */
-export declare const betterAuthTenant: <const RelationTo extends string>({ relationTo, onDelete, platform, }: {
+export declare const betterAuthTenant: <const RelationTo extends string>({ relationTo, onDelete, newRows, backoffice, organizations, }: {
     /** The kayan a row's tenant is, Better Auth's `organization`. */
     relationTo: RelationTo;
     /** `restrict`: a tenant still holding a row is not deleted. */
     onDelete: 'restrict';
+    /** A new row on a tenant-owned kayan takes the active organization, through an operation or a step's insert/upsert; naming another organization is refused. */
+    newRows: 'active';
     /**
-     * Whether this actor is platform staff in the trusted platform app, who may read every
+     * Whether this actor is backoffice staff in the trusted backoffice app, who may read every
      * tenant with `tenant: 'all'`. The answer is the project's: it decides which app is trusted.
      */
-    platform?: (args: {
+    backoffice?: (args: {
         user: unknown;
     }) => boolean | Promise<boolean>;
+    /**
+     * How many organizations the project holds: `'one'` or `'many'`. Both keep the field and the
+     * scope; in `'one'` a `connect()` refuses to start over more than one. Whether a project shows its
+     * one organization is the project's own concern.
+     */
+    organizations: 'one' | 'many';
 }) => TenantTarget<RelationTo>;

package/dist/auth/better-auth/tenant.js

@@ -2,7 +2,7 @@
  * The tenant target over Better Auth's organizations, laid down under `targets.tenant`.
  * A tenant-owned kayan places its field, `organizationId: tenant.field`.
  */
-export const betterAuthTenant = ({ relationTo, onDelete, platform, }) => {
+export const betterAuthTenant = ({ relationTo, onDelete, newRows, backoffice, organizations, }) => {
     if (typeof relationTo !== 'string' || !relationTo) {
         throw new Error('betterAuthTenant needs relationTo, the name of the kayan a row\'s tenant is, such as "organization".');
     }
@@ -11,11 +11,19 @@ export const betterAuthTenant = ({ relationTo, onDelete, platform, }) => {
     if (onDelete !== 'restrict') {
         throw new Error(`betterAuthTenant takes onDelete: 'restrict' alone, and was handed ${JSON.stringify(onDelete)}.`);
     }
+    if (newRows !== 'active') {
+        throw new Error(`betterAuthTenant takes newRows: 'active' alone, and was handed ${JSON.stringify(newRows)}.`);
+    }
+    if (!['one', 'many'].includes(organizations)) {
+        throw new Error(`betterAuthTenant takes organizations: 'one' or 'many', and was handed ${JSON.stringify(organizations)}.`);
+    }
     return {
         capability: 'tenant',
         relationTo,
         onDelete,
-        ...(platform && { platform }),
+        newRows,
+        organizations,
+        ...(backoffice && { backoffice }),
         field: {
             kind: 'relationship',
             relationTo,

package/dist/auth/local/index.js

@@ -4,7 +4,7 @@ import { SignJWT, jwtVerify } from 'jose';
 import { declaredFieldAccess } from '../../mithaq/rows.js';
 import { providerOf } from '../../base/rules.js';
 import { accessReport, isAdminActor, markAuthActor, resolveAssigned } from '../../asas/actor.js';
-import { AsasError, codes, denied as refused, Notice } from '../../asas/runner/errors.js';
+import { AsasError, codes, retryConflict, denied as refused, Notice } from '../../asas/runner/errors.js';
 import { firstRegisters, running } from '../../asas/runner/runtime.js';
 import { drain } from '../../asas/runner/write.js';
 import { insert, neverRead, sealOf, update } from '../../asas/runner/steps.js';
@@ -721,8 +721,10 @@ export const localAuthStrategy = ({ options, kayan: resolved, target, writes, pr
                 }
             }
             catch (error) {
-                // Matched on the status the store translates from the SQLSTATE, not a sentence that
-                // changes with a locale. Any 409 in this handler answers in these words.
+                error = retryConflict(error);
+                if (error instanceof AsasError && error.key === 'error.conflict.retry')
+                    return json({ code: codes[409], message: error.message, data: { key: error.key, params: error.params } }, { status: 409 });
+                // The driver detail may name another account, so other conflicts keep the existing refusal.
                 if (error instanceof AsasError && error.status === 409) {
                     return refusal(409, 'Email already exists.');
                 }

package/dist/base/fields.d.ts

@@ -51,7 +51,8 @@ export declare const defaultTimestampFields: {
 };
 /**
  * The `id`, `updatedAt` and `createdAt` fields a kayan spreads into its own
- * `fields`: `fields: { ...defaultFields, title }`. Spread order is column order.
+ * `fields`: `fields: { ...defaultFields, title }`. Spread order is column order, except that
+ * a new table puts the two timestamps after every other column.
  */
 export declare const defaultFields: {
     /** A uuid Postgres fills when a create leaves it out; a client may send its own, so rows can be made offline. */
@@ -103,7 +104,7 @@ export declare const globalTypeLabel: {
 };
 /**
  * The field a global spreads into its own `fields`:
- * `fields: { ...defaultFields, siteTitle, ...defaultGlobalFields }`.
+ * `fields: { ...defaultFields, ...defaultGlobalFields, siteTitle }`.
  */
 export declare const defaultGlobalFields: {
     readonly globalType: {

package/dist/base/fields.js

@@ -33,13 +33,14 @@ export const defaultTimestampFields = {
 };
 /**
  * The `id`, `updatedAt` and `createdAt` fields a kayan spreads into its own
- * `fields`: `fields: { ...defaultFields, title }`. Spread order is column order.
+ * `fields`: `fields: { ...defaultFields, title }`. Spread order is column order, except that
+ * a new table puts the two timestamps after every other column.
  */
 export const defaultFields = { ...defaultIdField, ...defaultTimestampFields };
 export const globalTypeLabel = { en: 'Global type', ar: 'النوع العام' };
 /**
  * The field a global spreads into its own `fields`:
- * `fields: { ...defaultFields, siteTitle, ...defaultGlobalFields }`.
+ * `fields: { ...defaultFields, ...defaultGlobalFields, siteTitle }`.
  */
 export const defaultGlobalFields = {
     globalType: {

package/dist/base/index.d.ts

@@ -15,13 +15,14 @@ export declare const base: {
         relationship: import("./kinds.ts").Kind<string | number, "defaultValue" | "index" | "onDelete" | "providedBy" | "required" | "unique"> & {
             pointsAtRow: true;
         };
+        json: import("./kinds.ts").Kind<import("./kinds.ts").Json, "defaultValue" | "providedBy" | "required">;
         join: import("./kinds.ts").Kind<unknown[], "providedBy" | "required">;
     };
     readonly rules: {
         required: import("./rules.ts").Rule<boolean>;
         unique: import("./rules.ts").Rule<boolean>;
         index: import("./rules.ts").Rule<boolean>;
-        defaultValue: import("./rules.ts").Rule<string | number | boolean | Date | readonly unknown[] | import("../index.ts").Ref>;
+        defaultValue: import("./rules.ts").Rule<Date | readonly unknown[] | import("../index.ts").Ref | import("./kinds.ts").Json>;
         defaultNow: import("./rules.ts").Rule<boolean>;
         nowOnUpdate: import("./rules.ts").Rule<boolean>;
         providedBy: import("./rules.ts").Rule<Readonly<{

package/dist/base/json-schema.d.ts

@@ -0,0 +1,7 @@
+import type { ResolvedField } from '../mithaq/types.ts';
+/**
+ * Whether a value holds to a `json` field's `jsonSchema`. A schema that names draft-07, as Payload
+ * writes one it fetched, is read as draft-07; any other as 2020-12. Throws, naming the field, where
+ * the schema cannot be compiled, so a build refuses it rather than checking less than it says.
+ */
+export declare const jsonSchemaCheck: (field: ResolvedField) => ((value: unknown) => boolean);

package/dist/base/json-schema.js

@@ -0,0 +1,35 @@
+// Ajv, not zod's `fromJSONSchema`, which Payload uses: the converter passes over `required` without
+// `properties`, and every keyword of a schema that names no `type`, so a value it waves through would
+// break the schema the project wrote. Ajv holds a value to the whole schema, and refuses one it
+// cannot hold a value to (an unknown keyword or format, a reference it cannot resolve) when it compiles.
+import { Ajv } from 'ajv';
+import { Ajv2020 } from 'ajv/dist/2020.js';
+import addFormats from 'ajv-formats';
+// One compile per schema, though a schema target shapes each field more than once.
+const compiled = new WeakMap();
+/**
+ * Whether a value holds to a `json` field's `jsonSchema`. A schema that names draft-07, as Payload
+ * writes one it fetched, is read as draft-07; any other as 2020-12. Throws, naming the field, where
+ * the schema cannot be compiled, so a build refuses it rather than checking less than it says.
+ */
+export const jsonSchemaCheck = (field) => {
+    const jsonSchema = field.jsonSchema;
+    const held = compiled.get(jsonSchema);
+    if (held)
+        return held;
+    const { schema } = jsonSchema;
+    // `strictTypes` and `strictTuples` only ask a schema to say more than JSON Schema requires.
+    const options = { strictTypes: false, strictTuples: false };
+    const ajv = typeof schema === 'object' && /^http:\/\/json-schema\.org\/draft-07\/schema#?$/.test(String(schema.$schema)) ? new Ajv(options) : new Ajv2020(options);
+    addFormats.default(ajv);
+    let validate;
+    try {
+        validate = ajv.compile(schema);
+    }
+    catch (thrown) {
+        throw new Error(`Kayan "${field.kayan}" field "${field.name}" jsonSchema cannot be checked: ${thrown.message}.`, { cause: thrown });
+    }
+    const check = (value) => validate(value) === true;
+    compiled.set(jsonSchema, check);
+    return check;
+};

package/dist/base/kinds.d.ts

@@ -34,6 +34,26 @@ export declare const kind: <Value>(accepts: (value: unknown) => value is Value)
 }) & (PointsAtRow extends true ? {
     pointsAtRow: true;
 } : unknown);
+/** A value `JSON.parse` could hand back. */
+export type Json = null | boolean | number | string | Json[] | {
+    [key: string]: Json;
+};
+/**
+ * The most UTF-8 bytes of JSON text a json field holds, which a field names as its `maxBytes`, so one write
+ * never stores a value every read of the row then carries.
+ */
+export declare const defaultJsonMaxBytes = 1000000;
+/** How deep a json value nests: past it every reader that walks it, this check first, would run out of stack. */
+export declare const jsonDepth = 64;
+/** Text Postgres holds: no NUL, which no `text` or `jsonb` takes, and no half of a surrogate pair. */
+export declare const isStorableText: (text: string) => boolean;
+/**
+ * Plain JSON, nested at most `jsonDepth` deep: no `undefined`, no number that is
+ * not finite, no `Date`, class instance or function, no cycle, and no string or key
+ * Postgres cannot store. A store would otherwise drop, rewrite or refuse it on the
+ * way in, and read back something else.
+ */
+export declare const isJson: (value: unknown, open?: object[]) => value is Json;
 /** What the database does to this row when the row it points at is deleted. */
 export type OnDelete = 'cascade' | 'restrict' | 'set null';
 export declare const defaultKinds: {
@@ -50,5 +70,6 @@ export declare const defaultKinds: {
     relationship: Kind<string | number, "defaultValue" | "index" | "onDelete" | "providedBy" | "required" | "unique"> & {
         pointsAtRow: true;
     };
+    json: Kind<Json, "defaultValue" | "providedBy" | "required">;
     join: Kind<unknown[], "providedBy" | "required">;
 };

package/dist/base/kinds.js

@@ -1,6 +1,40 @@
 import { isDecimal } from './decimal.js';
 /** Defines a project kind from its runtime check. */
 export const kind = (accepts) => (definition) => ({ ...definition, value: undefined, accepts });
+/**
+ * The most UTF-8 bytes of JSON text a json field holds, which a field names as its `maxBytes`, so one write
+ * never stores a value every read of the row then carries.
+ */
+export const defaultJsonMaxBytes = 1_000_000;
+/** How deep a json value nests: past it every reader that walks it, this check first, would run out of stack. */
+export const jsonDepth = 64;
+/** Text Postgres holds: no NUL, which no `text` or `jsonb` takes, and no half of a surrogate pair. */
+export const isStorableText = (text) => !text.includes('\u0000') && text.isWellFormed();
+/**
+ * Plain JSON, nested at most `jsonDepth` deep: no `undefined`, no number that is
+ * not finite, no `Date`, class instance or function, no cycle, and no string or key
+ * Postgres cannot store. A store would otherwise drop, rewrite or refuse it on the
+ * way in, and read back something else.
+ */
+export const isJson = (value, open = []) => {
+    if (typeof value === 'string')
+        return isStorableText(value);
+    if (value === null || typeof value === 'boolean')
+        return true;
+    if (typeof value === 'number')
+        return Number.isFinite(value);
+    if (typeof value !== 'object' || open.length >= jsonDepth || open.includes(value))
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    if (!Array.isArray(value) && prototype !== Object.prototype && prototype !== null)
+        return false;
+    open.push(value);
+    // `Object.values` skips a hole, which `JSON.stringify` would write as `null`, so the length is checked too.
+    const plain = (Array.isArray(value) ? Object.keys(value).length === value.length : Object.keys(value).every(isStorableText))
+        && Object.values(value).every((one) => isJson(one, open));
+    open.pop();
+    return plain;
+};
 export const defaultKinds = {
     text: kind((value) => typeof value === 'string')({
         label: { en: 'Text', ar: 'نص' },
@@ -66,7 +100,18 @@ export const defaultKinds = {
         message: { en: 'Pick one of the listed entries.', ar: 'اختر عنصرًا من القائمة.' },
         rules: ['providedBy', 'required', 'unique', 'index', 'defaultValue', 'onDelete'],
         pointsAtRow: true,
-        onDelete: 'set null',
+        // A row another still names is never deleted from under it, its drafts included; a field says
+        // `set null` or `cascade` to let it go.
+        onDelete: 'restrict',
+    }),
+    // Payload's `json` field, unwrapped, so each reads a row the other wrote. Nothing orders by one:
+    // jsonb's order is no order a person reads.
+    json: kind(isJson)({
+        label: { en: 'JSON', ar: 'JSON' },
+        message: { en: 'This is not JSON this field takes.', ar: 'هذه ليست بيانات JSON يقبلها هذا الحقل.' },
+        rules: ['providedBy', 'required', 'defaultValue'],
+        operators: ['equals', 'not_equals', 'in', 'not_in', 'exists', 'like', 'contains'],
+        sortable: false,
     }),
     // The rows of another kayan whose `on` relationship points at this one. It builds
     // no column: the id lives on the child, and a read populates it through the child's access.

package/dist/base/rules.d.ts

@@ -1,6 +1,6 @@
 import { type Ref } from '../mithaq/user.ts';
 import type { Localized } from '../mithaq/types.ts';
-import type { OnDelete } from './kinds.ts';
+import { type Json, type OnDelete } from './kinds.ts';
 export type Rule<Value = unknown> = {
     /** Compile-time value carried by a binding; never read at runtime. */
     value: Value;
@@ -33,8 +33,8 @@ export declare const defaultRules: {
     required: Rule<boolean>;
     unique: Rule<boolean>;
     index: Rule<boolean>;
-    /** A literal, or `user.<key>` for the actor's value. Each row gets its own copy. */
-    defaultValue: Rule<string | number | boolean | Date | readonly unknown[] | Ref>;
+    /** A literal, JSON for a `json` field, or `user.<key>` for the actor's value. Each row gets its own copy. */
+    defaultValue: Rule<Date | readonly unknown[] | Ref | Json>;
     /** The moment of the write, on create. */
     defaultNow: Rule<boolean>;
     /** The moment of the write, on every update, whatever the column is called. */
@@ -63,7 +63,7 @@ export declare const defaultRules: {
     uppercase: Rule<boolean>;
     lowercase: Rule<boolean>;
     trim: Rule<boolean>;
-    /** What happens to this row when the row it points at is deleted. Left out, a required relationship restricts and an optional one is set null. */
+    /** What happens to this row when the row it points at is deleted. Left out, a required field and a set restrict and any other takes its kind's default. */
     onDelete: Rule<OnDelete>;
 };
 /** The rule keys a field may carry, derived from the record the language names. */

package/dist/base/rules.js

@@ -1,4 +1,5 @@
 import { isRef } from '../mithaq/user.js';
+import { isJson } from './kinds.js';
 /** Defines a project rule from its runtime check. */
 export const rule = ({ accepts, message, excludes, }) => ({ value: undefined, accepts, message, excludes });
 const isBoolean = (value) => typeof value === 'boolean';
@@ -14,9 +15,9 @@ export const defaultRules = {
     required: rule({ accepts: isBoolean, message: { en: 'This field is required.', ar: 'هذا الحقل مطلوب.' } }),
     unique: boolean,
     index: boolean,
-    /** A literal, or `user.<key>` for the actor's value. Each row gets its own copy. */
+    /** A literal, JSON for a `json` field, or `user.<key>` for the actor's value. Each row gets its own copy. */
     defaultValue: rule({
-        accepts: (value) => value instanceof Date || isRef(value) || Array.isArray(value) || ['boolean', 'number', 'string'].includes(typeof value),
+        accepts: (value) => value instanceof Date || isRef(value) || Array.isArray(value) || (value !== null && isJson(value)),
         excludes: ['defaultNow'],
     }),
     /** The moment of the write, on create. */
@@ -73,7 +74,7 @@ export const defaultRules = {
     uppercase: rule({ accepts: isBoolean, excludes: ['lowercase'] }),
     lowercase: rule({ accepts: isBoolean, excludes: ['uppercase'] }),
     trim: boolean,
-    /** What happens to this row when the row it points at is deleted. Left out, a required relationship restricts and an optional one is set null. */
+    /** What happens to this row when the row it points at is deleted. Left out, a required field and a set restrict and any other takes its kind's default. */
     onDelete: rule({
         accepts: (value) => typeof value === 'string' && ['cascade', 'restrict', 'set null'].includes(value),
     }),

package/dist/drizzle/index.d.ts

@@ -1,6 +1,6 @@
 import { type SQL } from 'drizzle-orm';
 import { type NodePgDatabase } from 'drizzle-orm/node-postgres';
-import { pgTable, type AnyPgColumnBuilder, type PgBooleanBuilder, type PgBuildColumns, type PgEnum, type PgDateStringBuilder, type PgIntegerBuilder, type PgNumericBuilder, type PgNumericNumberBuilder, type PgSchema, type PgSerialBuilder, type PgTable, type PgTableWithColumns, type PgTextBuilder, type PgTimestampBuilder, type PgUUIDBuilder, type PgVarcharBuilder, type SetDimensions, type SetHasDefault, type SetNotNull } from 'drizzle-orm/pg-core';
+import { pgTable, type AnyPgColumnBuilder, type PgBooleanBuilder, type PgBuildColumns, type PgEnum, type PgDateStringBuilder, type PgIntegerBuilder, type PgJsonbBuilder, type PgNumericBuilder, type PgNumericNumberBuilder, type PgSchema, type PgSerialBuilder, type PgTable, type PgTableWithColumns, type PgTextBuilder, type PgTimestampBuilder, type PgUUIDBuilder, type PgVarcharBuilder, type SetDimensions, type SetHasDefault, type SetNotNull } from 'drizzle-orm/pg-core';
 import type { ResolvedField, ResolvedKayan, RuntimeField } from '../mithaq/types.ts';
 import type { Store } from '../mithaq/language.ts';
 import type { Operator } from '../mithaq/where.ts';
@@ -65,6 +65,8 @@ type ShippedBuilder<F, List extends Registry, Name> = F extends {
 } ? PgTimestampBuilder : F extends {
     kind: 'date';
 } ? PgDateStringBuilder : F extends {
+    kind: 'json';
+} ? PgJsonbBuilder : F extends {
     rules: {
         maxLength: number;
     };
@@ -166,6 +168,8 @@ export declare const manyFields: (kayan: ResolvedKayan | undefined) => ({
         readonly value: string;
         readonly label: Readonly<Record<string, string>>;
     }[] | undefined;
+    jsonSchema?: import("../mithaq/types.ts").JsonSchema;
+    maxBytes?: number;
     dbName?: string;
     targets?: Record<string, unknown>;
     custom?: Record<string, unknown>;
@@ -174,6 +178,7 @@ export declare const manyFields: (kayan: ResolvedKayan | undefined) => ({
     rules?: Record<string, unknown>;
     relationTo?: string | (() => import("../mithaq/types.ts").Kayan);
     hasMany?: true;
+    filterOptions?: import("../mithaq/types.ts").FilterOptions;
     on?: string;
     defaultLimit?: number;
     defaultSort?: string;
@@ -188,7 +193,7 @@ export declare const manyFields: (kayan: ResolvedKayan | undefined) => ({
     operators?: readonly Operator[];
     sortable?: false;
     filesIn?: readonly string[];
-    richText?: (value: unknown) => import("../rich-text/rich-text.ts").RichTextRead;
+    richText?: (value: unknown) => import("../rich-text/value.ts").RichTextRead;
     target?: ResolvedKayan;
 })[];
 export declare const schemaOf: (table: unknown) => string;
@@ -267,141 +272,6 @@ export declare const recordMigration: ({ db, hash, createdAt, name }: {
     createdAt: number;
     name: string;
 }) => Promise<void>;
-/** The drizzle store target's maps: a map per kind and a map per rule. */
-export declare const drizzleTarget: {
-    readonly capability: 'store';
-    readonly type: 'drizzle';
-    readonly idKinds: ("number" | "text" | "uuid")[];
-    readonly kinds: {
-        number: (field: ResolvedField) => PgNumericNumberBuilder | PgSerialBuilder;
-        integer: (field: ResolvedField) => PgIntegerBuilder;
-        decimal: (field: ResolvedField) => PgNumericBuilder;
-        text: (field: ResolvedField) => PgTextBuilder<[string, ...string[]]> | PgVarcharBuilder<[string, ...string[]]>;
-        email: (field: ResolvedField) => PgTextBuilder<[string, ...string[]]> | PgVarcharBuilder<[string, ...string[]]>;
-        checkbox: (field: ResolvedField) => PgBooleanBuilder;
-        textArray: (field: ResolvedField) => SetDimensions<PgTextBuilder<[string, ...string[]]>, 1>;
-        uuid: (field: ResolvedField) => PgUUIDBuilder;
-        datetime: (field: ResolvedField) => PgTimestampBuilder;
-        date: (field: ResolvedField) => PgDateStringBuilder;
-        join: (field: ResolvedField) => never;
-        relationship: ColumnBuilder;
-    };
-    readonly rules: {
-        primary: ({ column }: {
-            column: Modifiable;
-            value: undefined;
-            field: ResolvedField;
-        }) => Modifiable;
-        required: ({ column, value: on }: {
-            column: Modifiable;
-            value: boolean;
-            field: ResolvedField;
-        }) => Modifiable;
-        unique: ({ column }: {
-            column: Modifiable;
-            value: boolean;
-            field: ResolvedField;
-        }) => Modifiable;
-        index: ({ column }: {
-            column: Modifiable;
-            value: boolean;
-            field: ResolvedField;
-        }) => Modifiable;
-        defaultValue: ({ column, value }: {
-            column: Modifiable;
-            value: string | number | boolean | Date | readonly unknown[] | import("../index.ts").Ref;
-            field: ResolvedField;
-        }) => Modifiable;
-        defaultNow: ({ column, value: on, field }: {
-            column: Modifiable;
-            value: boolean;
-            field: ResolvedField;
-        }) => any;
-        nowOnUpdate: ({ column }: {
-            column: Modifiable;
-            value: boolean;
-            field: ResolvedField;
-        }) => Modifiable;
-        providedBy: ({ column }: {
-            column: Modifiable;
-            value: Readonly<{
-                create?: import("../base/rules.ts").Provider;
-                update?: import("../base/rules.ts").Provider;
-            }>;
-            field: ResolvedField;
-        }) => Modifiable;
-        onDelete: ({ column }: {
-            column: Modifiable;
-            value: import("../index.ts").OnDelete;
-            field: ResolvedField;
-        }) => Modifiable;
-        localized: ({ column }: {
-            column: Modifiable;
-            value: boolean;
-            field: ResolvedField;
-        }) => Modifiable;
-        maxLength: ({ column }: {
-            column: Modifiable;
-            value: number;
-            field: ResolvedField;
-        }) => Modifiable;
-        precision: ({ column }: {
-            column: Modifiable;
-            value: number;
-            field: ResolvedField;
-        }) => Modifiable;
-        scale: ({ column }: {
-            column: Modifiable;
-            value: number;
-            field: ResolvedField;
-        }) => Modifiable;
-        minLength: ({ column }: {
-            column: Modifiable;
-            value: number;
-            field: ResolvedField;
-        }) => Modifiable;
-        pattern: ({ column }: {
-            column: Modifiable;
-            value: RegExp;
-            field: ResolvedField;
-        }) => Modifiable;
-        min: ({ column }: {
-            column: Modifiable;
-            value: string | number;
-            field: ResolvedField;
-        }) => Modifiable;
-        max: ({ column }: {
-            column: Modifiable;
-            value: string | number;
-            field: ResolvedField;
-        }) => Modifiable;
-        minRows: ({ column }: {
-            column: Modifiable;
-            value: number;
-            field: ResolvedField;
-        }) => Modifiable;
-        maxRows: ({ column }: {
-            column: Modifiable;
-            value: number;
-            field: ResolvedField;
-        }) => Modifiable;
-        uppercase: ({ column }: {
-            column: Modifiable;
-            value: boolean;
-            field: ResolvedField;
-        }) => Modifiable;
-        lowercase: ({ column }: {
-            column: Modifiable;
-            value: boolean;
-            field: ResolvedField;
-        }) => Modifiable;
-        trim: ({ column }: {
-            column: Modifiable;
-            value: boolean;
-            field: ResolvedField;
-        }) => Modifiable;
-    };
-};
 type DrizzleAdapterArguments<Kinds, Rules> = {
     /** A ready drizzle instance, so the pool, logger and options are the developer's. */
     db?: Database;
@@ -409,8 +279,8 @@ type DrizzleAdapterArguments<Kinds, Rules> = {
     connectionString?: string;
     kinds: Kinds;
     rules: Rules;
-    /** The kinds this store builds an id of; set it where you replace the kinds map and its relationship builder. */
-    idKinds?: readonly string[];
+    /** The kinds this store builds an id of; `drizzleIdKinds`, unless you replace the kinds map and its relationship builder. */
+    idKinds: readonly string[];
     /** Push the schema on connect instead of running migrations. */
     push?: boolean;
     /**