@drhomet/mithaq 0.0.0-stage → 0.2.0

package/dist/base/rules.js

@@ -0,0 +1,81 @@
+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';
+const isNumber = (value) => typeof value === 'number';
+const boolean = rule({ accepts: isBoolean });
+const writeOperations = ['create', 'update'];
+// `never` is not `application`: not "something else fills it" but "nobody does, for this operation".
+const providers = ['client', 'application', 'never'];
+/** Who supplies a field's value on one operation; a field that declares nothing is the client's. */
+export const providerOf = (field, on) => field.rules?.providedBy?.[on] ?? 'client';
+/** The shipped rules, which a project passes to `defineMithaq` and may add its own to. */
+export const defaultRules = {
+    required: rule({ accepts: isBoolean, message: { en: 'This field is required.', ar: 'هذا الحقل مطلوب.' } }),
+    unique: boolean,
+    index: boolean,
+    /** 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) || (value !== null && isJson(value)),
+        excludes: ['defaultNow'],
+    }),
+    /** The moment of the write, on create. */
+    defaultNow: rule({ accepts: isBoolean, excludes: ['defaultValue', 'localized'] }),
+    /** The moment of the write, on every update, whatever the column is called. */
+    nowOnUpdate: rule({ accepts: isBoolean, excludes: ['localized'] }),
+    /** Who supplies the value on create and on update. A field declaring nothing is the client's on both. */
+    providedBy: rule({
+        accepts: (value) => !!value &&
+            typeof value === 'object' &&
+            !Array.isArray(value) &&
+            Object.entries(value).every(([operation, supplier]) => writeOperations.includes(operation) && providers.includes(supplier)),
+    }),
+    /** One value per locale the language declares: one column per locale, and an object keyed by locale in every shape. */
+    localized: boolean,
+    /** Length is a rule, not a kind: `text` with a maximum is `varchar(n)`. */
+    maxLength: rule({ accepts: isNumber, message: { en: 'The value is too long.', ar: 'القيمة طويلة جدًا.' } }),
+    /** A decimal's size, `numeric(precision, scale)`: declare both or neither. A value with more digits is refused, not rounded. */
+    precision: rule({
+        accepts: (value) => Number.isInteger(value) && value >= 1 && value <= 1000,
+        message: { en: 'The value has too many digits.', ar: 'القيمة فيها أرقام أكثر من المسموح.' },
+    }),
+    scale: rule({
+        accepts: (value) => Number.isInteger(value) && value >= 0 && value <= 1000,
+        message: { en: 'The value has too many decimal places.', ar: 'القيمة فيها منازل عشرية أكثر من المسموح.' },
+    }),
+    minLength: rule({ accepts: isNumber, message: { en: 'The value is too short.', ar: 'القيمة أقصر من المسموح.' } }),
+    pattern: rule({
+        accepts: (value) => value instanceof RegExp,
+        message: {
+            en: 'The value is not in the shape this field takes.',
+            ar: 'القيمة ليست بالشكل الذي يقبله هذا الحقل.',
+        },
+    }),
+    /** A bound on an ordered value: a number for `number`, an ISO day for `date`. */
+    min: rule({
+        accepts: (value) => typeof value === 'number' || typeof value === 'string',
+        message: { en: 'The value is too small.', ar: 'القيمة أصغر من المسموح.' },
+    }),
+    max: rule({
+        accepts: (value) => typeof value === 'number' || typeof value === 'string',
+        message: { en: 'The value is too large.', ar: 'القيمة أكبر من المسموح.' },
+    }),
+    /** How few and how many rows a list holds. A list that is not `required` may be left empty whatever its floor. */
+    minRows: rule({
+        accepts: (value) => Number.isInteger(value) && value >= 0,
+        message: { en: 'This list has too few entries.', ar: 'هذه القائمة فيها عناصر أقل من المسموح.' },
+    }),
+    maxRows: rule({
+        accepts: (value) => Number.isInteger(value) && value >= 0,
+        message: { en: 'This list has too many entries.', ar: 'هذه القائمة فيها عناصر أكثر من المسموح.' },
+    }),
+    /** Rewrites the value's case before any check judges it; never refuses a value for its case. */
+    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 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

@@ -0,0 +1,308 @@
+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 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';
+type Database = NodePgDatabase;
+export type Tables = Record<string, ReturnType<typeof pgTable>>;
+export type Schemas = Record<string, PgSchema | null>;
+/** Every enum a built column uses, keyed `<schema>.<name>`. */
+export type Enums = Record<string, PgEnum<[string, ...string[]]>>;
+type Registry = readonly {
+    name: string;
+    fields: Record<string, RuntimeField>;
+}[];
+type Related<F, List extends Registry> = F extends {
+    relationTo: infer Relation;
+} ? Relation extends string ? Extract<List[number], {
+    name: Relation;
+}> : Relation extends () => {
+    name: infer Name;
+} ? Extract<List[number], {
+    name: Name;
+}> : never : never;
+type OwnBuilder<F, Kinds> = F extends {
+    kind: infer Kind extends keyof Kinds;
+} ? Kinds[Kind] extends {
+    readonly targets: {
+        readonly drizzle: (...args: never[]) => infer Own extends AnyPgColumnBuilder;
+    };
+} ? Own : never : never;
+type BaseBuilder<F, List extends Registry, Name, Store extends PropertyKey, Kinds> = F extends {
+    targets: Record<Store, infer Override extends AnyPgColumnBuilder>;
+} ? Override : F extends {
+    relationTo: unknown;
+} ? ReferenceBuilder<F, List> : [OwnBuilder<F, Kinds>] extends [never] ? ShippedBuilder<F, List, Name> : OwnBuilder<F, Kinds>;
+/** A foreign key takes the type of the id it points at. */
+type ReferenceBuilder<F, List extends Registry> = Related<F, List> extends {
+    fields: {
+        id: {
+            kind: 'number';
+        };
+    };
+} ? PgIntegerBuilder : Related<F, List> extends {
+    fields: {
+        id: {
+            kind: 'uuid';
+        };
+    };
+} ? PgUUIDBuilder : PgTextBuilder;
+type ShippedBuilder<F, List extends Registry, Name> = F extends {
+    kind: 'number';
+} ? Name extends 'id' ? PgSerialBuilder : PgNumericNumberBuilder : F extends {
+    kind: 'integer';
+} ? PgIntegerBuilder : F extends {
+    kind: 'decimal';
+} ? PgNumericBuilder : F extends {
+    kind: 'uuid';
+} ? PgUUIDBuilder : F extends {
+    kind: 'checkbox';
+} ? PgBooleanBuilder : F extends {
+    kind: 'textArray';
+} ? SetDimensions<PgTextBuilder, 1> : F extends {
+    kind: 'datetime';
+} ? PgTimestampBuilder : F extends {
+    kind: 'date';
+} ? PgDateStringBuilder : F extends {
+    kind: 'json';
+} ? PgJsonbBuilder : F extends {
+    rules: {
+        maxLength: number;
+    };
+} ? PgVarcharBuilder : PgTextBuilder;
+type DefaultedBuilder<B extends AnyPgColumnBuilder, F, Name> = Name extends 'id' ? SetHasDefault<B> : F extends {
+    rules: {
+        defaultValue: unknown;
+    };
+} | {
+    rules: {
+        defaultNow: true;
+    };
+} ? SetHasDefault<B> : B;
+type PreparedBuilder<B extends AnyPgColumnBuilder, F, Name> = B extends AnyPgColumnBuilder ? F extends {
+    rules: {
+        required: true;
+    };
+} ? SetNotNull<DefaultedBuilder<B, F, Name>> : DefaultedBuilder<B, F, Name> : never;
+type NameOf<K> = K extends {
+    name: infer Name extends string;
+} ? Name : string;
+type TableName<K> = K extends {
+    dbName?: infer Name extends string;
+} ? string extends Name ? NameOf<K> : Name : NameOf<K>;
+type Builders<K, List extends Registry, Store extends PropertyKey, Kinds> = K extends {
+    fields: infer Fields extends Record<string, RuntimeField>;
+} ? {
+    [Name in keyof Fields as Fields[Name] extends {
+        hasMany: true;
+    } | {
+        kind: 'join';
+    } ? never : Name]: PreparedBuilder<BaseBuilder<Fields[Name], List, Name, Store, Kinds>, Fields[Name], Name>;
+} : never;
+type SnakeRest<S extends string> = S extends `${infer Head}${infer Rest}` ? Lowercase<Head> extends Head ? `${Head}${SnakeRest<Rest>}` : `_${Lowercase<Head>}${SnakeRest<Rest>}` : '';
+type SnakeCase<S extends string> = S extends `${infer Head}${infer Rest}` ? `${Lowercase<Head>}${SnakeRest<Rest>}` : S;
+/** The join table names one kayan's `hasMany` fields ask for, as `joinTableOf` builds them. */
+type JoinNames<K> = K extends {
+    fields: infer Fields;
+} ? {
+    [Name in keyof Fields]: Fields[Name] extends {
+        hasMany: true;
+    } ? `${TableName<K>}_${SnakeCase<Name & string>}` : never;
+}[keyof Fields] : never;
+type VersionsName<K> = `_${TableName<K>}_versions`;
+type StoreKayan<K, StoreName extends PropertyKey, DefaultStore extends PropertyKey> = K extends {
+    targets: {
+        service: {
+            store: infer Named;
+        };
+    };
+} ? Named extends StoreName ? K : never : DefaultStore extends StoreName ? K : never;
+type TableFor<K, List extends Registry, Store extends PropertyKey, Kinds> = K extends {
+    targets: Record<Store, infer Override>;
+} ? Override : PgTableWithColumns<{
+    name: TableName<K>;
+    schema: undefined;
+    columns: PgBuildColumns<TableName<K>, Builders<K, List, Store, Kinds>>;
+    dialect: 'pg';
+}>;
+/** Concrete tables built for one store, keyed by registered kayan names. */
+export type BuiltTables<List extends Registry, StoreName extends PropertyKey, DefaultStore extends PropertyKey, Kinds = {}> = {
+    [K in StoreKayan<List[number], StoreName, DefaultStore> as K['name']]: TableFor<K, List, StoreName, Kinds>;
+} & {
+    [K in StoreKayan<List[number], StoreName, DefaultStore> as JoinNames<K>]: ReturnType<typeof pgTable>;
+} & {
+    [K in StoreKayan<List[number], StoreName, DefaultStore> as VersionsName<K>]?: ReturnType<typeof pgTable>;
+};
+/** Builds one field's column. `tables` is every table built so far, keyed by kayan name, which a foreign key reads lazily. */
+export type ColumnBuilder = (field: ResolvedField, tables: Tables) => AnyPgColumnBuilder;
+type Modifiable = AnyPgColumnBuilder & {
+    default(value: unknown): Modifiable;
+    notNull(): Modifiable;
+    primaryKey(): Modifiable;
+    unique(): Modifiable;
+};
+export declare const joinTableOf: (kayan: ResolvedKayan, field: ResolvedField) => string;
+/** The fields of one kayan the store holds as a join table rather than a column. */
+export declare const manyFields: (kayan: ResolvedKayan | undefined) => ({
+    access?: {
+        create?: import("../mithaq/types.ts").FieldAccess<unknown, Record<string, unknown>, unknown, Partial<Record<string, unknown>>> | (import("../mithaq/types.ts").ActorBoundAccess<unknown> & {
+            readonly __mithaqFieldData: unknown;
+            readonly __mithaqFieldId: unknown;
+        });
+        read?: import("../mithaq/types.ts").FieldAccess<unknown, Record<string, unknown>, unknown, Partial<Record<string, unknown>>> | (import("../mithaq/types.ts").ActorBoundAccess<unknown> & {
+            readonly __mithaqFieldData: unknown;
+            readonly __mithaqFieldId: unknown;
+        });
+        update?: import("../mithaq/types.ts").FieldAccess<unknown, Record<string, unknown>, unknown, Partial<Record<string, unknown>>> | (import("../mithaq/types.ts").ActorBoundAccess<unknown> & {
+            readonly __mithaqFieldData: unknown;
+            readonly __mithaqFieldId: unknown;
+        });
+    };
+    label?: import("../mithaq/types.ts").LabelFunction | Readonly<Record<string, string>> | undefined;
+    description?: import("../mithaq/types.ts").LabelFunction | Readonly<Record<string, string>> | undefined;
+    placeholder?: import("../mithaq/types.ts").LabelFunction | Readonly<Record<string, string>> | undefined;
+    prefix?: Readonly<Record<string, string>> | undefined;
+    suffix?: Readonly<Record<string, string>> | undefined;
+    options?: readonly {
+        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>;
+} & {
+    kind: string;
+    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;
+} & {
+    name: string;
+    column: string;
+    kayan?: string;
+    schemaTarget?: string;
+    locales?: readonly string[];
+    now?: () => unknown;
+    kindTargets?: Readonly<Record<string, unknown>>;
+    operators?: readonly Operator[];
+    sortable?: false;
+    filesIn?: readonly string[];
+    richText?: (value: unknown) => import("../rich-text/value.ts").RichTextRead;
+    target?: ResolvedKayan;
+})[];
+export declare const schemaOf: (table: unknown) => string;
+export type ColumnRule<Value = never> = (args: {
+    column: Modifiable;
+    value: Value;
+    field: ResolvedField;
+}) => Modifiable;
+/** The drizzle store: a store, plus the drizzle instance and the tables it built, read off `asas.targets.drizzle`. */
+export type Adapter = Omit<Store, 'kinds' | 'rules'> & {
+    kinds: Record<string, ColumnBuilder>;
+    rules: Record<string, ColumnRule>;
+    readonly type: 'drizzle';
+    /** Declared, never sniffed: what says the two members below are drizzle's. */
+    readonly sql: 'drizzle';
+    db: Database;
+    tables: Tables;
+    /** Every schema the built tables are in. The push hands them to drizzle-kit, which writes no `CREATE SCHEMA` otherwise. */
+    schemas: Schemas;
+    /** Every enum a built column uses, keyed `<schema>.<name>`. drizzle-kit writes no `CREATE TYPE` for one it is not handed. */
+    enums: Enums;
+    /** The string this adapter made its instance from, which `mithaq migrate` writes into the drizzle-kit config. */
+    readonly connectionString?: string;
+};
+export declare const devPushMarker = "mithaq_dev_push";
+export declare const migrationsTable: {
+    readonly schema: 'drizzle';
+    readonly table: '__mithaq_migrations';
+};
+export declare const refuseStrangers: ({ db, tables, by }: {
+    db: {
+        execute(query: SQL): Promise<{
+            rows: unknown[];
+        }>;
+    };
+    tables: Tables;
+    /** What would drop the stranger, which the sentence names. */
+    by: 'push' | 'baseline';
+}) => Promise<void>;
+export declare const pushInput: ({ tables, schemas, held }: {
+    tables: Tables;
+    schemas: Schemas;
+    held?: {
+        schema: string;
+        name: string;
+        labels: string[];
+        owned: boolean;
+    }[];
+}) => {
+    imports: Record<string, unknown>;
+    filter: {
+        schemas: string[];
+        tables: any[];
+        entities: undefined;
+        extensions: never[];
+    };
+};
+/** The history table as SQL, for the statements that read and write it. */
+export declare const historyTable: SQL<unknown>;
+/**
+ * The one lock every writer of the history takes, a production boot running drizzle's migrator
+ * and a connect making the table, since both create the `drizzle` schema. Keyed as a boot has
+ * always keyed it, so an instance of an older release booting beside this one still waits.
+ */
+export declare const historyLock: SQL<unknown>;
+type HistoryDb = {
+    execute(query: SQL): Promise<unknown>;
+    transaction<T>(run: (tx: {
+        execute(query: SQL): Promise<unknown>;
+    }) => Promise<T>): Promise<T>;
+};
+export declare const createHistory: (db: HistoryDb) => Promise<void>;
+export declare const recordMigration: ({ db, hash, createdAt, name }: {
+    db: HistoryDb;
+    hash: string;
+    createdAt: number;
+    name: string;
+}) => Promise<void>;
+type DrizzleAdapterArguments<Kinds, Rules> = {
+    /** A ready drizzle instance, so the pool, logger and options are the developer's. */
+    db?: Database;
+    /** Or a connection string, and the adapter makes the instance. */
+    connectionString?: string;
+    kinds: Kinds;
+    rules: Rules;
+    /** 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;
+    /**
+     * What a production `connect()` does with migrations this database has not applied: `run` applies them
+     * in one transaction before serving, `refuse` refuses to start. Without it a production connect refuses.
+     */
+    prodMigrations?: ProdMigrations;
+};
+/** Where a production connect finds the migrations folder, and what it does with pending ones. */
+export type ProdMigrations = {
+    /** The folder of migration folders, as drizzle's own migrator takes it: relative to the working directory, or absolute. */
+    migrationsFolder: string;
+    pending: 'run' | 'refuse';
+};
+export declare const drizzleAdapter: <const Kinds extends Record<string, ColumnBuilder>, const Rules extends Record<string, ColumnRule>>({ db: ready, connectionString, kinds, rules, idKinds, push: named, prodMigrations, }: DrizzleAdapterArguments<Kinds, Rules>) => Omit<Adapter, 'kinds' | 'rules'> & {
+    kinds: Kinds;
+    rules: Rules;
+};
+declare module '../mithaq/rukn.ts' {
+    /** A kayan's entry under its drizzle store is its whole table, unbuilt, used as written. */
+    interface KayanConfigs<L, F, T> {
+        drizzle: PgTable;
+    }
+}
+export {};