@zeroxsolutions/db 9.5.0 → 10.1.0

package/dist/base/postgres/repository.js

@@ -1,17 +1,22 @@
-import { and, count, eq, getTableColumns, getViewSelectedFields, isNull, sql, } from 'drizzle-orm';
-import { resolveRelationalRead, selectedColumns } from '../../utils/index.js';
-import { buildOrderBy, DEFAULT_OFFSET, DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE } from '../../utils/index.js';
-import { totalOrder } from '../../utils/total-order.js';
-/** A Postgres repository over `TTable` with CRUD, pagination, soft-delete, and relation loading. */
+import { and, count, eq, getTableColumns, getViewSelectedFields, inArray, sql, } from 'drizzle-orm';
+import { orderOf, whereOf } from '../../utils/filter.js';
+import { plainColumns } from '../../utils/read.js';
+import { conditionOf, liveCondition, loadsRelations, orderClausesOf, primaryKeyFields, queryDelegateOf, relationalReadOf, } from '../read-engine.js';
+/** A Postgres repository over `TTable`: reads that name what they load, soft delete, and writes keyed by id. */
 export class BaseRepository {
     db;
     table;
     queryKey;
-    /** @param queryKey - omitted: `findAll`/`findOne` throw if called with `with` or `include`, and a fieldset names no relation. */
-    constructor(db, table, queryKey) {
+    reads;
+    /**
+     * @param queryKey - the table's EXPORT name in the schema; omitted, a read that loads a relation throws
+     * @param reads - the context's `READS`: each table's order as a relation, and its `virtual` names
+     */
+    constructor(db, table, queryKey, reads = {}) {
         this.db = db;
         this.table = table;
         this.queryKey = queryKey;
+        this.reads = reads;
     }
     getExecutor(tx) {
         const executor = tx ?? this.db;
@@ -19,82 +24,111 @@ export class BaseRepository {
             throw new Error('Database executor is not available');
         return executor;
     }
-    async findAll(where, options) {
-        const columns = getTableColumns(this.table);
-        const limit = Math.min(options?.limit ?? DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE);
-        const offset = options?.offset ?? DEFAULT_OFFSET;
-        let _where = where;
-        if (!options?.softDeleted && columns.deletedAt)
-            _where = and(where, isNull(columns.deletedAt));
-        const executor = this.getExecutor(options?.tx);
-        const read = resolveRelationalRead(executor, this.queryKey, this.table, options);
-        // The key after the caller's sort: rows that tie on it have no order of their own, and two pages
-        // cut from two orders of the same rows repeat one and skip another.
-        const orderClauses = buildOrderBy(this.table, totalOrder(this.table, options?.sort));
-        if (read.with) {
-            if (!this.queryKey)
-                throw new Error('queryKey must be provided to use the "with" option.');
-            const queries = executor.query;
-            const safeQueryKey = String(this.queryKey);
-            const queryDelegate = queries[safeQueryKey];
-            if (!queryDelegate)
-                throw new Error(`Invalid queryKey: ${safeQueryKey}`);
-            return await queryDelegate.findMany({
-                where: _where,
-                limit,
-                offset,
-                columns: read.columns,
-                with: read.with,
-                orderBy: orderClauses,
+    get source() {
+        return {
+            table: this.table,
+            queryKey: this.queryKey,
+            reads: this.reads,
+            caseInsensitiveOperator: true,
+        };
+    }
+    idColumn(action) {
+        const column = getTableColumns(this.table)['id'];
+        if (!column)
+            throw new Error(`${action} by id is not supported for this table`);
+        return column;
+    }
+    async findOneById(id, options) {
+        return this.findOneWhere(eq(this.idColumn('Find one'), id), options);
+    }
+    async findAllById(ids, options) {
+        const column = this.idColumn('Find all');
+        if (ids.length === 0)
+            return [];
+        return this.findAllWhere(inArray(column, [...ids]), options);
+    }
+    async existsById(id, options) {
+        return this.existsWhere(eq(this.idColumn('Exists'), id), options);
+    }
+    async findAll(options) {
+        return this.findAllWhere(undefined, options);
+    }
+    async findAllAndCount(options) {
+        return this.findAllAndCountWhere(undefined, options);
+    }
+    async count(options) {
+        return this.countWhere(undefined, options);
+    }
+    /** The rows matching `where` and the options, in their order and page window. */
+    async findAllWhere(where, options) {
+        const executor = this.getExecutor();
+        const condition = conditionOf(this.source, executor, where, options);
+        const order = orderClausesOf(this.source, executor, options);
+        if (loadsRelations(options?.read)) {
+            const config = relationalReadOf(this.source, executor, options?.read);
+            return queryDelegateOf(executor, String(this.queryKey)).findMany({
+                ...config,
+                where: condition,
+                orderBy: order,
+                limit: options?.limit,
+                offset: options?.offset,
             });
         }
-        const rows = await executor
-            .select(selectedColumns(columns, read.columns))
+        let query = executor
+            .select(this.plainSelection(options?.read))
             .from(this.table)
-            .limit(limit)
-            .offset(offset)
-            .where(_where)
-            .orderBy(...orderClauses);
-        return rows;
+            .where(condition)
+            .orderBy(...order)
+            .$dynamic();
+        if (options?.limit !== undefined)
+            query = query.limit(options.limit);
+        if (options?.offset !== undefined)
+            query = query.offset(options.offset);
+        return (await query);
     }
-    async findAllAndCount(where, options) {
-        return await Promise.all([this.findAll(where, options), this.count(where, options)]);
+    /** {@link findAllWhere} and {@link countWhere} over the same `where` and filter, so the total matches the page. */
+    async findAllAndCountWhere(where, options) {
+        return await Promise.all([this.findAllWhere(where, options), this.countWhere(where, options)]);
     }
-    async findOne(where, options) {
-        const columns = getTableColumns(this.table);
-        let _where = where;
-        if (!options?.softDeleted && columns.deletedAt)
-            _where = and(where, isNull(columns.deletedAt));
-        const executor = this.getExecutor(options?.tx);
-        const read = resolveRelationalRead(executor, this.queryKey, this.table, options);
-        if (read.with) {
-            if (!this.queryKey)
-                throw new Error('queryKey must be provided to use the "with" option.');
-            const queries = executor.query;
-            const safeQueryKey = String(this.queryKey);
-            const queryDelegate = queries[safeQueryKey];
-            if (!queryDelegate)
-                throw new Error(`Invalid queryKey: ${safeQueryKey}`);
-            const result = await queryDelegate.findFirst({
-                where: _where,
-                columns: read.columns,
-                with: read.with,
+    /** The first row matching `where`, loaded as the options' `read` names. */
+    async findOneWhere(where, options) {
+        const executor = this.getExecutor();
+        const condition = and(where, liveCondition(this.table, options?.softDeleted));
+        if (loadsRelations(options?.read)) {
+            const config = relationalReadOf(this.source, executor, options?.read);
+            const row = await queryDelegateOf(executor, String(this.queryKey)).findFirst({
+                ...config,
+                where: condition,
             });
-            return result ?? null;
+            return row ?? null;
         }
         const rows = await executor
-            .select(selectedColumns(columns, read.columns))
+            .select(this.plainSelection(options?.read))
             .from(this.table)
-            .where(_where)
+            .where(condition)
             .limit(1);
         return rows[0] ?? null;
     }
-    async findOneById(id, options) {
+    /** How many rows match `where` and the options' filter. */
+    async countWhere(where, options) {
+        const result = await this.getExecutor()
+            .select({ count: count() })
+            .from(this.table)
+            .where(conditionOf(this.source, this.getExecutor(), where, options));
+        return result[0]?.count ?? 0;
+    }
+    /** Whether any row matches `where` and the options' filter. */
+    async existsWhere(where, options) {
+        const result = await this.getExecutor()
+            .select({ value: sql `1` })
+            .from(this.table)
+            .where(conditionOf(this.source, this.getExecutor(), where, options))
+            .limit(1);
+        return result.length > 0;
+    }
+    plainSelection(read) {
         const columns = getTableColumns(this.table);
-        if (!columns.id) {
-            throw new Error('Find one by id is not supported for this table');
-        }
-        return this.findOne(eq(columns.id, id), options);
+        return plainColumns(columns, primaryKeyFields(this.table), read, String(this.queryKey ?? 'table'));
     }
     async create(data, options) {
         const rows = await this.getExecutor(options?.tx).insert(this.table).values(data).returning();
@@ -104,53 +138,38 @@ export class BaseRepository {
         const rows = await this.getExecutor(options?.tx).insert(this.table).values(data).returning();
         return rows;
     }
-    async update(where, data, options) {
-        const rows = await this.getExecutor(options?.tx).update(this.table).set(data).where(where).returning();
-        return rows[0];
-    }
     async updateById(id, data, options) {
-        const columns = getTableColumns(this.table);
-        if (!columns.id) {
-            throw new Error('Update by id is not supported for this table');
-        }
-        return await this.update(eq(columns.id, id), data, options);
-    }
-    async delete(where, options) {
-        await this.getExecutor(options?.tx).delete(this.table).where(where);
+        return await this.updateWhere(eq(this.idColumn('Update'), id), data, options);
     }
     async deleteById(id, options) {
-        const columns = getTableColumns(this.table);
-        if (!columns.id) {
-            throw new Error('Delete by id is not supported for this table');
-        }
-        await this.delete(eq(columns.id, id), options);
+        await this.deleteWhere(eq(this.idColumn('Delete'), id), options);
     }
-    async count(where, options) {
-        const columns = getTableColumns(this.table);
-        const executor = this.getExecutor(options?.tx);
-        let _where = where;
-        if (!options?.softDeleted && columns.deletedAt)
-            _where = and(where, isNull(columns.deletedAt));
-        const result = await executor
-            .select({ count: count() })
-            .from(this.table)
-            .where(_where);
-        return result[0]?.count ?? 0;
+    async deleteAllById(ids, options) {
+        const column = this.idColumn('Delete all');
+        if (ids.length === 0)
+            return;
+        await this.deleteWhere(inArray(column, [...ids]), options);
     }
-    async exists(where, options) {
-        const columns = getTableColumns(this.table);
-        const executor = this.getExecutor(options?.tx);
-        let _where = where;
-        if (!options?.softDeleted && columns.deletedAt)
-            _where = and(where, isNull(columns.deletedAt));
-        const result = await executor
-            .select({ value: sql `1` })
-            .from(this.table)
-            .where(_where)
-            .limit(1);
-        return result.length > 0;
+    async softDeleteById(id, options) {
+        await this.softDeleteWhere(eq(this.idColumn('Soft delete'), id), options);
+    }
+    async softDeleteAllById(ids, options) {
+        const column = this.idColumn('Soft delete all');
+        if (ids.length === 0)
+            return;
+        await this.softDeleteWhere(inArray(column, [...ids]), options);
     }
-    async softDelete(where, options) {
+    /** Updates the rows matching `where`, answering the first. */
+    async updateWhere(where, data, options) {
+        const rows = await this.getExecutor(options?.tx).update(this.table).set(data).where(where).returning();
+        return rows[0] ?? null;
+    }
+    /** Removes the rows matching `where`. */
+    async deleteWhere(where, options) {
+        await this.getExecutor(options?.tx).delete(this.table).where(where);
+    }
+    /** Marks the rows matching `where` deleted. */
+    async softDeleteWhere(where, options) {
         const columns = getTableColumns(this.table);
         if (!columns.deletedAt) {
             throw new Error('Soft delete is not supported for this table');
@@ -160,13 +179,7 @@ export class BaseRepository {
             .set({ deletedAt: new Date() })
             .where(where);
     }
-    async softDeleteById(id, options) {
-        const columns = getTableColumns(this.table);
-        if (!columns.id || !columns.deletedAt) {
-            throw new Error('Soft delete by id is not supported for this table');
-        }
-        await this.softDelete(eq(columns.id, id), options);
-    }
+    /** Sets `field` to null on every row whose `field` holds `value`. */
     async nullifyBy(field, value, options) {
         const columns = getTableColumns(this.table);
         const column = columns[field];
@@ -180,15 +193,18 @@ export class BaseRepository {
     }
 }
 /**
- * A read-only repository over a Postgres materialized view, with paginated reads and a refresh. A view has no
- * `deletedAt` and no relational config, and its order is the one its own definition states.
+ * A read-only repository over a Postgres materialized view. A view has no `deletedAt` and no relational config, and it
+ * is read back with no order of its own, so every order ends on the columns of its unique index.
  */
 export class BaseViewRepository {
     db;
     viewTable;
-    constructor(db, viewTable) {
+    key;
+    /** @param key - the columns of the view's unique index, appended to every order as a table's primary key is */
+    constructor(db, viewTable, key) {
         this.db = db;
         this.viewTable = viewTable;
+        this.key = key;
     }
     getExecutor(tx) {
         const executor = tx ?? this.db;
@@ -196,40 +212,63 @@ export class BaseViewRepository {
             throw new Error('Database executor is not available');
         return executor;
     }
-    /** The view's selected fields, narrowed to the fieldset `options` gives it. */
-    selectedFields(options) {
-        const read = resolveRelationalRead(undefined, undefined, this.viewTable, { fields: options?.fields });
+    /** The view's selected fields, which a filter and an order resolve against. */
+    get selectable() {
         // drizzle types a view's selection as `ColumnsSelection`, values `unknown`; it is the object its own `select()` reads.
-        return selectedColumns(getViewSelectedFields(this.viewTable), read.columns);
+        return getViewSelectedFields(this.viewTable);
     }
-    async findAll(where, options) {
-        const limit = Math.min(options?.limit ?? DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE);
-        const executor = this.getExecutor(options?.tx);
-        return (await executor
-            .select(this.selectedFields(options))
+    get fields() {
+        return {
+            columns: this.selectable,
+            relationKeys: {},
+            virtual: {},
+            at: new Date(),
+            context: undefined,
+            caseInsensitiveOperator: true,
+        };
+    }
+    async findAll(options) {
+        return this.findAllWhere(undefined, options);
+    }
+    async findAllAndCount(options) {
+        return this.findAllAndCountWhere(undefined, options);
+    }
+    async count(options) {
+        return this.countWhere(undefined, options);
+    }
+    /** The view rows matching `where` and the options, in their order and page window. */
+    async findAllWhere(where, options) {
+        let query = this.getExecutor()
+            .select(plainColumns(this.selectable, this.key, options?.read, 'view'))
             .from(this.viewTable)
-            .limit(limit)
-            .offset(options?.offset ?? DEFAULT_OFFSET)
-            .where(where));
+            .where(and(where, whereOf(this.fields, options?.filter)))
+            .orderBy(...orderOf(this.fields, options?.orderBy, this.key))
+            .$dynamic();
+        if (options?.limit !== undefined)
+            query = query.limit(options.limit);
+        if (options?.offset !== undefined)
+            query = query.offset(options.offset);
+        return (await query);
     }
-    async findOne(where, options) {
-        const executor = this.getExecutor(options?.tx);
-        const rows = await executor
-            .select(this.selectedFields(options))
+    /** The first view row matching `where`. */
+    async findOneWhere(where, options) {
+        const rows = await this.getExecutor()
+            .select(plainColumns(this.selectable, this.key, options?.read, 'view'))
             .from(this.viewTable)
             .where(where)
             .limit(1);
         return rows[0] ?? null;
     }
-    async findAllAndCount(where, options) {
-        return await Promise.all([this.findAll(where, options), this.count(where, options)]);
+    /** {@link findAllWhere} and {@link countWhere} over the same `where` and filter. */
+    async findAllAndCountWhere(where, options) {
+        return await Promise.all([this.findAllWhere(where, options), this.countWhere(where, options)]);
     }
-    async count(where, options) {
-        const executor = this.getExecutor(options?.tx);
-        const result = await executor
+    /** How many view rows match `where` and the options' filter. */
+    async countWhere(where, options) {
+        const result = await this.getExecutor()
             .select({ count: count() })
             .from(this.viewTable)
-            .where(where);
+            .where(and(where, whereOf(this.fields, options?.filter)));
         return result[0]?.count ?? 0;
     }
     async refresh(options) {

package/dist/base/postgres/unit-of-work.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"unit-of-work.d.ts","sourceRoot":"","sources":["../../../src/base/postgres/unit-of-work.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD;;;;GAIG;AACH,qBAAa,iBAAiB,CAAC,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,CACnF,YAAW,WAAW,CAAC,aAAa,CAAC;IAGnC,OAAO,CAAC,QAAQ,CAAC,EAAE;IACnB,OAAO,CAAC,QAAQ,CAAC,gBAAgB;gBADhB,EAAE,EAAE,kBAAkB,CAAC,OAAO,CAAC,EAC/B,gBAAgB,EAAE,CAAC,EAAE,EAAE,WAAW,CAAC,OAAO,CAAC,KAAK,aAAa;IAGhF,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,YAAY,EAAE,aAAa,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;CAGtE"}
+{"version":3,"file":"unit-of-work.d.ts","sourceRoot":"","sources":["../../../src/base/postgres/unit-of-work.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD;;;;GAIG;AACH,qBAAa,iBAAiB,CAC5B,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACvC,aAAa,CACb,YAAW,WAAW,CAAC,aAAa,CAAC;IAEnC,OAAO,CAAC,QAAQ,CAAC,EAAE;IACnB,OAAO,CAAC,QAAQ,CAAC,gBAAgB;gBADhB,EAAE,EAAE,kBAAkB,CAAC,OAAO,CAAC,EAC/B,gBAAgB,EAAE,CAAC,EAAE,EAAE,WAAW,CAAC,OAAO,CAAC,KAAK,aAAa;IAGhF,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,YAAY,EAAE,aAAa,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;CAGtE"}

package/dist/base/read-engine.d.ts

@@ -0,0 +1,48 @@
+import { type SQL, type Table } from 'drizzle-orm';
+import { type FieldContext } from '../utils/filter.js';
+import { type MatchOptions, type Read, type RelationalConfig, type RelationalMetadata } from '../utils/read.js';
+import type { TableReads } from '../utils/reads.js';
+/**
+ * What every base repository reads with, whichever engine runs it: the table, its export name in the schema, and the
+ * context's `READS`.
+ */
+export interface ReadSource {
+    table: Table;
+    queryKey: string | undefined;
+    reads: Readonly<Record<string, TableReads | undefined>>;
+    /** Postgres matches text with `ILIKE`; SQLite has none. */
+    caseInsensitiveOperator: boolean;
+}
+/** The relational config a drizzle client was built with, or `undefined` for one built with no schema. */
+export declare function metadataOf(executor: unknown): RelationalMetadata | undefined;
+/**
+ * The property keys of the table's primary key columns, in the order the key declares them.
+ *
+ * A composite key sets no column's `primary` flag, so it is read off the table config instead, and matched back by SQL
+ * name: the key holds its own copies of the columns, so its column objects are not the table's (drizzle-orm@0.45.1).
+ */
+export declare function primaryKeyFields(table: Table): string[];
+/** What resolving a filter or an order name of this table needs, decided at `at` against `context`. */
+export declare function fieldContextOf(source: ReadSource, executor: unknown, options: Pick<MatchOptions, 'at' | 'context'> | undefined): FieldContext;
+/** The root table's soft-delete condition, unless the read asks for marked rows or the table marks none. */
+export declare function liveCondition(table: Table, softDeleted: boolean | undefined): SQL | undefined;
+/** A finder's own `where`, the caller's filter and the soft-delete condition, joined. */
+export declare function conditionOf(source: ReadSource, executor: unknown, where: SQL | undefined, options: MatchOptions | undefined): SQL | undefined;
+/** The order a read of many rows runs in, the primary key appended. */
+export declare function orderClausesOf(source: ReadSource, executor: unknown, options: ({
+    orderBy?: readonly {
+        field: string;
+        direction: 'asc' | 'desc';
+    }[];
+} & Pick<MatchOptions, 'at' | 'context'>) | undefined): SQL[];
+/** Whether a read loads any relation, which only drizzle's relational query can. */
+export declare function loadsRelations(read: Read | undefined): boolean;
+/**
+ * The relational config a read resolves into, for drizzle's `findFirst` / `findMany`.
+ *
+ * @throws Error when the repository has no `queryKey` or its client no schema, which a relation needs
+ */
+export declare function relationalReadOf(source: ReadSource, executor: unknown, read: Read | undefined): Pick<RelationalConfig, 'columns' | 'with'>;
+/** The relational query delegate drizzle builds for the table exported as `queryKey`. */
+export declare function queryDelegateOf<TDelegate>(executor: unknown, queryKey: string): TDelegate;
+//# sourceMappingURL=read-engine.d.ts.map

package/dist/base/read-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-engine.d.ts","sourceRoot":"","sources":["../../src/base/read-engine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsD,KAAK,GAAG,EAAE,KAAK,KAAK,EAAE,MAAM,aAAa,CAAC;AAGvG,OAAO,EAAoB,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACzE,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,IAAI,EACT,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EAExB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,KAAK,CAAC;IACb,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,GAAG,SAAS,CAAC,CAAC,CAAC;IACxD,2DAA2D;IAC3D,uBAAuB,EAAE,OAAO,CAAC;CAClC;AAED,0GAA0G;AAC1G,wBAAgB,UAAU,CAAC,QAAQ,EAAE,OAAO,GAAG,kBAAkB,GAAG,SAAS,CAM5E;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,EAAE,CAOvD;AAiBD,uGAAuG;AACvG,wBAAgB,cAAc,CAC5B,MAAM,EAAE,UAAU,EAClB,QAAQ,EAAE,OAAO,EACjB,OAAO,EAAE,IAAI,CAAC,YAAY,EAAE,IAAI,GAAG,SAAS,CAAC,GAAG,SAAS,GACxD,YAAY,CAUd;AAED,4GAA4G;AAC5G,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,OAAO,GAAG,SAAS,GAAG,GAAG,GAAG,SAAS,CAG7F;AAED,yFAAyF;AACzF,wBAAgB,WAAW,CACzB,MAAM,EAAE,UAAU,EAClB,QAAQ,EAAE,OAAO,EACjB,KAAK,EAAE,GAAG,GAAG,SAAS,EACtB,OAAO,EAAE,YAAY,GAAG,SAAS,GAChC,GAAG,GAAG,SAAS,CAGjB;AAED,uEAAuE;AACvE,wBAAgB,cAAc,CAC5B,MAAM,EAAE,UAAU,EAClB,QAAQ,EAAE,OAAO,EACjB,OAAO,EACH,CAAC;IAAE,OAAO,CAAC,EAAE,SAAS;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,KAAK,GAAG,MAAM,CAAA;KAAE,EAAE,CAAA;CAAE,GAAG,IAAI,CAAC,YAAY,EAAE,IAAI,GAAG,SAAS,CAAC,CAAC,GAC9G,SAAS,GACZ,GAAG,EAAE,CAEP;AAED,oFAAoF;AACpF,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,GAAG,SAAS,GAAG,OAAO,CAE9D;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,UAAU,EAClB,QAAQ,EAAE,OAAO,EACjB,IAAI,EAAE,IAAI,GAAG,SAAS,GACrB,IAAI,CAAC,gBAAgB,EAAE,SAAS,GAAG,MAAM,CAAC,CAS5C;AAED,yFAAyF;AACzF,wBAAgB,eAAe,CAAC,SAAS,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,CAKzF"}

package/dist/base/read-engine.js

@@ -0,0 +1,94 @@
+import { and, getTableColumns, is, isNull, One } from 'drizzle-orm';
+import { getTableConfig as getPgTableConfig, PgTable } from 'drizzle-orm/pg-core';
+import { getTableConfig as getSQLiteTableConfig } from 'drizzle-orm/sqlite-core';
+import { orderOf, whereOf } from '../utils/filter.js';
+import { relationalConfig, } from '../utils/read.js';
+/** The relational config a drizzle client was built with, or `undefined` for one built with no schema. */
+export function metadataOf(executor) {
+    const internals = executor._;
+    if (!internals?.schema || !internals.tableNamesMap)
+        return undefined;
+    return { tables: internals.schema, tableNamesMap: internals.tableNamesMap };
+}
+/**
+ * The property keys of the table's primary key columns, in the order the key declares them.
+ *
+ * A composite key sets no column's `primary` flag, so it is read off the table config instead, and matched back by SQL
+ * name: the key holds its own copies of the columns, so its column objects are not the table's (drizzle-orm@0.45.1).
+ */
+export function primaryKeyFields(table) {
+    const columns = getTableColumns(table);
+    const fieldOf = new Map(Object.entries(columns).map(([field, column]) => [column.name, field]));
+    const declared = Object.values(columns).filter((column) => column.primary);
+    if (declared.length > 0)
+        return declared.flatMap((column) => fieldOf.get(column.name) ?? []);
+    const config = is(table, PgTable) ? getPgTableConfig(table) : getSQLiteTableConfig(table);
+    return (config.primaryKeys[0]?.columns ?? []).flatMap((column) => fieldOf.get(column.name) ?? []);
+}
+/**
+ * Each relation of the table that reaches one row through a column the table itself holds, mapped to that column: a
+ * relationship filter compares the related row's id, which is that column's value.
+ */
+function relationKeysOf(source, metadata) {
+    if (!metadata || source.queryKey === undefined)
+        return {};
+    const relations = metadata.tables[source.queryKey]?.relations ?? {};
+    const keys = {};
+    for (const [name, relation] of Object.entries(relations)) {
+        const fields = is(relation, One) ? relation.config?.fields : undefined;
+        if (fields?.length === 1 && fields[0])
+            keys[name] = fields[0];
+    }
+    return keys;
+}
+/** What resolving a filter or an order name of this table needs, decided at `at` against `context`. */
+export function fieldContextOf(source, executor, options) {
+    const metadata = metadataOf(executor);
+    return {
+        columns: getTableColumns(source.table),
+        relationKeys: relationKeysOf(source, metadata),
+        virtual: (source.queryKey !== undefined ? source.reads[source.queryKey]?.virtual : undefined) ?? {},
+        at: options?.at ?? new Date(),
+        context: options?.context,
+        caseInsensitiveOperator: source.caseInsensitiveOperator,
+    };
+}
+/** The root table's soft-delete condition, unless the read asks for marked rows or the table marks none. */
+export function liveCondition(table, softDeleted) {
+    const columns = getTableColumns(table);
+    return !softDeleted && columns['deletedAt'] ? isNull(columns['deletedAt']) : undefined;
+}
+/** A finder's own `where`, the caller's filter and the soft-delete condition, joined. */
+export function conditionOf(source, executor, where, options) {
+    const context = fieldContextOf(source, executor, options);
+    return and(where, whereOf(context, options?.filter), liveCondition(source.table, options?.softDeleted));
+}
+/** The order a read of many rows runs in, the primary key appended. */
+export function orderClausesOf(source, executor, options) {
+    return orderOf(fieldContextOf(source, executor, options), options?.orderBy, primaryKeyFields(source.table));
+}
+/** Whether a read loads any relation, which only drizzle's relational query can. */
+export function loadsRelations(read) {
+    return read?.relations !== undefined && Object.keys(read.relations).length > 0;
+}
+/**
+ * The relational config a read resolves into, for drizzle's `findFirst` / `findMany`.
+ *
+ * @throws Error when the repository has no `queryKey` or its client no schema, which a relation needs
+ */
+export function relationalReadOf(source, executor, read) {
+    const metadata = metadataOf(executor);
+    if (source.queryKey === undefined || !metadata) {
+        throw new Error('A read loading a relation needs a queryKey and a client built with its schema.');
+    }
+    const orders = Object.fromEntries(Object.entries(source.reads).map(([key, declared]) => [key, declared?.orderBy]));
+    return relationalConfig(metadata, orders, source.queryKey, read);
+}
+/** The relational query delegate drizzle builds for the table exported as `queryKey`. */
+export function queryDelegateOf(executor, queryKey) {
+    const queries = executor.query;
+    const delegate = Object.hasOwn(queries, queryKey) ? queries[queryKey] : undefined;
+    if (!delegate)
+        throw new Error(`Invalid queryKey: ${queryKey}`);
+    return delegate;
+}