@drhomet/mithaq 0.0.0-stage → 0.1.1

package/dist/drizzle/index.d.ts

@@ -0,0 +1,438 @@
+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 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 {
+    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;
+    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;
+    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/rich-text.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>;
+/** 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;
+    /** Or a connection string, and the adapter makes the instance. */
+    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[];
+    /** 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 {};