@uql/core 1.0.12 → 3.1.0

package/dist/migrate/storage/databaseStorage.d.ts

@@ -0,0 +1,24 @@
+import type { MigrationStorage, QuerierPool, SqlQuerier } from '../../type/index.js';
+/**
+ * Stores migration state in a database table.
+ * Uses the querier's dialect for escaping and placeholders.
+ */
+export declare class DatabaseMigrationStorage implements MigrationStorage {
+    private readonly querierPool;
+    private readonly tableName;
+    private storageInitialized;
+    constructor(querierPool: QuerierPool, options?: {
+        tableName?: string;
+    });
+    ensureStorage(): Promise<void>;
+    private createTableIfNotExists;
+    executed(): Promise<string[]>;
+    /**
+     * Log a migration as executed - uses provided querier (within transaction)
+     */
+    logWithQuerier(querier: SqlQuerier, migrationName: string): Promise<void>;
+    /**
+     * Unlog a migration - uses provided querier (within transaction)
+     */
+    unlogWithQuerier(querier: SqlQuerier, migrationName: string): Promise<void>;
+}

package/dist/migrate/storage/databaseStorage.js

@@ -0,0 +1,77 @@
+import { isSqlQuerier } from '../../type/index.js';
+/**
+ * Stores migration state in a database table.
+ * Uses the querier's dialect for escaping and placeholders.
+ */
+export class DatabaseMigrationStorage {
+    querierPool;
+    tableName;
+    storageInitialized = false;
+    constructor(querierPool, options = {}) {
+        this.querierPool = querierPool;
+        this.tableName = options.tableName ?? 'uql_migrations';
+    }
+    async ensureStorage() {
+        if (this.storageInitialized) {
+            return;
+        }
+        const querier = await this.querierPool.getQuerier();
+        if (!isSqlQuerier(querier)) {
+            await querier.release();
+            throw new Error('DatabaseMigrationStorage requires a SQL-based querier');
+        }
+        try {
+            await this.createTableIfNotExists(querier);
+            this.storageInitialized = true;
+        }
+        finally {
+            await querier.release();
+        }
+    }
+    async createTableIfNotExists(querier) {
+        const { escapeId } = querier.dialect;
+        const sql = `
+      CREATE TABLE IF NOT EXISTS ${escapeId(this.tableName)} (
+        ${escapeId('name')} VARCHAR(255) PRIMARY KEY,
+        ${escapeId('executed_at')} TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `;
+        await querier.run(sql);
+    }
+    async executed() {
+        await this.ensureStorage();
+        const querier = await this.querierPool.getQuerier();
+        if (!isSqlQuerier(querier)) {
+            await querier.release();
+            throw new Error('DatabaseMigrationStorage requires a SQL-based querier');
+        }
+        try {
+            const { escapeId } = querier.dialect;
+            const sql = `SELECT ${escapeId('name')} FROM ${escapeId(this.tableName)} ORDER BY ${escapeId('name')} ASC`;
+            const results = await querier.all(sql);
+            return results.map((r) => r.name);
+        }
+        finally {
+            await querier.release();
+        }
+    }
+    /**
+     * Log a migration as executed - uses provided querier (within transaction)
+     */
+    async logWithQuerier(querier, migrationName) {
+        await this.ensureStorage();
+        const { escapeId, placeholder } = querier.dialect;
+        const sql = `INSERT INTO ${escapeId(this.tableName)} (${escapeId('name')}) VALUES (${placeholder(1)})`;
+        await querier.run(sql, [migrationName]);
+    }
+    /**
+     * Unlog a migration - uses provided querier (within transaction)
+     */
+    async unlogWithQuerier(querier, migrationName) {
+        await this.ensureStorage();
+        const { escapeId, placeholder } = querier.dialect;
+        const sql = `DELETE FROM ${escapeId(this.tableName)} WHERE ${escapeId('name')} = ${placeholder(1)}`;
+        await querier.run(sql, [migrationName]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YWJhc2VTdG9yYWdlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL21pZ3JhdGUvc3RvcmFnZS9kYXRhYmFzZVN0b3JhZ2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBVW5EOzs7R0FHRztBQUNILE1BQU0sT0FBTyx3QkFBd0I7SUFLaEI7SUFKRixTQUFTLENBQVM7SUFDM0Isa0JBQWtCLEdBQUcsS0FBSyxDQUFDO0lBRW5DLFlBQ21CLFdBQXdCLEVBQ3pDLFVBRUksRUFBRTtRQUhXLGdCQUFXLEdBQVgsV0FBVyxDQUFhO1FBS3pDLElBQUksQ0FBQyxTQUFTLEdBQUcsT0FBTyxDQUFDLFNBQVMsSUFBSSxnQkFBZ0IsQ0FBQztJQUN6RCxDQUFDO0lBRUQsS0FBSyxDQUFDLGFBQWE7UUFDakIsSUFBSSxJQUFJLENBQUMsa0JBQWtCLEVBQUUsQ0FBQztZQUM1QixPQUFPO1FBQ1QsQ0FBQztRQUVELE1BQU0sT0FBTyxHQUFHLE1BQU0sSUFBSSxDQUFDLFdBQVcsQ0FBQyxVQUFVLEVBQUUsQ0FBQztRQUVwRCxJQUFJLENBQUMsWUFBWSxDQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUM7WUFDM0IsTUFBTSxPQUFPLENBQUMsT0FBTyxFQUFFLENBQUM7WUFDeEIsTUFBTSxJQUFJLEtBQUssQ0FBQyx1REFBdUQsQ0FBQyxDQUFDO1FBQzNFLENBQUM7UUFFRCxJQUFJLENBQUM7WUFDSCxNQUFNLElBQUksQ0FBQyxzQkFBc0IsQ0FBQyxPQUFPLENBQUMsQ0FBQztZQUMzQyxJQUFJLENBQUMsa0JBQWtCLEdBQUcsSUFBSSxDQUFDO1FBQ2pDLENBQUM7Z0JBQVMsQ0FBQztZQUNULE1BQU0sT0FBTyxDQUFDLE9BQU8sRUFBRSxDQUFDO1FBQzFCLENBQUM7SUFDSCxDQUFDO0lBRU8sS0FBSyxDQUFDLHNCQUFzQixDQUFDLE9BQW1CO1FBQ3RELE1BQU0sRUFBRSxRQUFRLEVBQUUsR0FBRyxPQUFPLENBQUMsT0FBTyxDQUFDO1FBQ3JDLE1BQU0sR0FBRyxHQUFHO21DQUNtQixRQUFRLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQztVQUNqRCxRQUFRLENBQUMsTUFBTSxDQUFDO1VBQ2hCLFFBQVEsQ0FBQyxhQUFhLENBQUM7O0tBRTVCLENBQUM7UUFFRixNQUFNLE9BQU8sQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDekIsQ0FBQztJQUVELEtBQUssQ0FBQyxRQUFRO1FBQ1osTUFBTSxJQUFJLENBQUMsYUFBYSxFQUFFLENBQUM7UUFFM0IsTUFBTSxPQUFPLEdBQUcsTUFBTSxJQUFJLENBQUMsV0FBVyxDQUFDLFVBQVUsRUFBRSxDQUFDO1FBRXBELElBQUksQ0FBQyxZQUFZLENBQUMsT0FBTyxDQUFDLEVBQUUsQ0FBQztZQUMzQixNQUFNLE9BQU8sQ0FBQyxPQUFPLEVBQUUsQ0FBQztZQUN4QixNQUFNLElBQUksS0FBSyxDQUFDLHVEQUF1RCxDQUFDLENBQUM7UUFDM0UsQ0FBQztRQUVELElBQUksQ0FBQztZQUNILE1BQU0sRUFBRSxRQUFRLEVBQUUsR0FBRyxPQUFPLENBQUMsT0FBTyxDQUFDO1lBQ3JDLE1BQU0sR0FBRyxHQUFHLFVBQVUsUUFBUSxDQUFDLE1BQU0sQ0FBQyxTQUFTLFFBQVEsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLGFBQWEsUUFBUSxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUM7WUFDM0csTUFBTSxPQUFPLEdBQUcsTUFBTSxPQUFPLENBQUMsR0FBRyxDQUFrQixHQUFHLENBQUMsQ0FBQztZQUN4RCxPQUFPLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFNLEVBQUUsRUFBRSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUN6QyxDQUFDO2dCQUFTLENBQUM7WUFDVCxNQUFNLE9BQU8sQ0FBQyxPQUFPLEVBQUUsQ0FBQztRQUMxQixDQUFDO0lBQ0gsQ0FBQztJQUVEOztPQUVHO0lBQ0gsS0FBSyxDQUFDLGNBQWMsQ0FBQyxPQUFtQixFQUFFLGFBQXFCO1FBQzdELE1BQU0sSUFBSSxDQUFDLGFBQWEsRUFBRSxDQUFDO1FBQzNCLE1BQU0sRUFBRSxRQUFRLEVBQUUsV0FBVyxFQUFFLEdBQUcsT0FBTyxDQUFDLE9BQU8sQ0FBQztRQUNsRCxNQUFNLEdBQUcsR0FBRyxlQUFlLFFBQVEsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLEtBQUssUUFBUSxDQUFDLE1BQU0sQ0FBQyxhQUFhLFdBQVcsQ0FBQyxDQUFDLENBQUMsR0FBRyxDQUFDO1FBQ3ZHLE1BQU0sT0FBTyxDQUFDLEdBQUcsQ0FBQyxHQUFHLEVBQUUsQ0FBQyxhQUFhLENBQUMsQ0FBQyxDQUFDO0lBQzFDLENBQUM7SUFFRDs7T0FFRztJQUNILEtBQUssQ0FBQyxnQkFBZ0IsQ0FBQyxPQUFtQixFQUFFLGFBQXFCO1FBQy9ELE1BQU0sSUFBSSxDQUFDLGFBQWEsRUFBRSxDQUFDO1FBQzNCLE1BQU0sRUFBRSxRQUFRLEVBQUUsV0FBVyxFQUFFLEdBQUcsT0FBTyxDQUFDLE9BQU8sQ0FBQztRQUNsRCxNQUFNLEdBQUcsR0FBRyxlQUFlLFFBQVEsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLFVBQVUsUUFBUSxDQUFDLE1BQU0sQ0FBQyxNQUFNLFdBQVcsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDO1FBQ3BHLE1BQU0sT0FBTyxDQUFDLEdBQUcsQ0FBQyxHQUFHLEVBQUUsQ0FBQyxhQUFhLENBQUMsQ0FBQyxDQUFDO0lBQzFDLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgTWlncmF0aW9uU3RvcmFnZSwgUXVlcmllclBvb2wsIFNxbFF1ZXJpZXIgfSBmcm9tICcuLi8uLi90eXBlL2luZGV4LmpzJztcbmltcG9ydCB7IGlzU3FsUXVlcmllciB9IGZyb20gJy4uLy4uL3R5cGUvaW5kZXguanMnO1xuXG4vKipcbiAqIE1pZ3JhdGlvbiBtZXRhZGF0YSBzdG9yZWQgaW4gdGhlIGRhdGFiYXNlXG4gKi9cbmludGVyZmFjZSBNaWdyYXRpb25SZWNvcmQge1xuICBuYW1lOiBzdHJpbmc7XG4gIGV4ZWN1dGVkX2F0OiBEYXRlIHwgbnVtYmVyO1xufVxuXG4vKipcbiAqIFN0b3JlcyBtaWdyYXRpb24gc3RhdGUgaW4gYSBkYXRhYmFzZSB0YWJsZS5cbiAqIFVzZXMgdGhlIHF1ZXJpZXIncyBkaWFsZWN0IGZvciBlc2NhcGluZyBhbmQgcGxhY2Vob2xkZXJzLlxuICovXG5leHBvcnQgY2xhc3MgRGF0YWJhc2VNaWdyYXRpb25TdG9yYWdlIGltcGxlbWVudHMgTWlncmF0aW9uU3RvcmFnZSB7XG4gIHByaXZhdGUgcmVhZG9ubHkgdGFibGVOYW1lOiBzdHJpbmc7XG4gIHByaXZhdGUgc3RvcmFnZUluaXRpYWxpemVkID0gZmFsc2U7XG5cbiAgY29uc3RydWN0b3IoXG4gICAgcHJpdmF0ZSByZWFkb25seSBxdWVyaWVyUG9vbDogUXVlcmllclBvb2wsXG4gICAgb3B0aW9uczoge1xuICAgICAgdGFibGVOYW1lPzogc3RyaW5nO1xuICAgIH0gPSB7fSxcbiAgKSB7XG4gICAgdGhpcy50YWJsZU5hbWUgPSBvcHRpb25zLnRhYmxlTmFtZSA/PyAndXFsX21pZ3JhdGlvbnMnO1xuICB9XG5cbiAgYXN5bmMgZW5zdXJlU3RvcmFnZSgpOiBQcm9taXNlPHZvaWQ+IHtcbiAgICBpZiAodGhpcy5zdG9yYWdlSW5pdGlhbGl6ZWQpIHtcbiAgICAgIHJldHVybjtcbiAgICB9XG5cbiAgICBjb25zdCBxdWVyaWVyID0gYXdhaXQgdGhpcy5xdWVyaWVyUG9vbC5nZXRRdWVyaWVyKCk7XG5cbiAgICBpZiAoIWlzU3FsUXVlcmllcihxdWVyaWVyKSkge1xuICAgICAgYXdhaXQgcXVlcmllci5yZWxlYXNlKCk7XG4gICAgICB0aHJvdyBuZXcgRXJyb3IoJ0RhdGFiYXNlTWlncmF0aW9uU3RvcmFnZSByZXF1aXJlcyBhIFNRTC1iYXNlZCBxdWVyaWVyJyk7XG4gICAgfVxuXG4gICAgdHJ5IHtcbiAgICAgIGF3YWl0IHRoaXMuY3JlYXRlVGFibGVJZk5vdEV4aXN0cyhxdWVyaWVyKTtcbiAgICAgIHRoaXMuc3RvcmFnZUluaXRpYWxpemVkID0gdHJ1ZTtcbiAgICB9IGZpbmFsbHkge1xuICAgICAgYXdhaXQgcXVlcmllci5yZWxlYXNlKCk7XG4gICAgfVxuICB9XG5cbiAgcHJpdmF0ZSBhc3luYyBjcmVhdGVUYWJsZUlmTm90RXhpc3RzKHF1ZXJpZXI6IFNxbFF1ZXJpZXIpOiBQcm9taXNlPHZvaWQ+IHtcbiAgICBjb25zdCB7IGVzY2FwZUlkIH0gPSBxdWVyaWVyLmRpYWxlY3Q7XG4gICAgY29uc3Qgc3FsID0gYFxuICAgICAgQ1JFQVRFIFRBQkxFIElGIE5PVCBFWElTVFMgJHtlc2NhcGVJZCh0aGlzLnRhYmxlTmFtZSl9IChcbiAgICAgICAgJHtlc2NhcGVJZCgnbmFtZScpfSBWQVJDSEFSKDI1NSkgUFJJTUFSWSBLRVksXG4gICAgICAgICR7ZXNjYXBlSWQoJ2V4ZWN1dGVkX2F0Jyl9IFRJTUVTVEFNUCBERUZBVUxUIENVUlJFTlRfVElNRVNUQU1QXG4gICAgICApXG4gICAgYDtcblxuICAgIGF3YWl0IHF1ZXJpZXIucnVuKHNxbCk7XG4gIH1cblxuICBhc3luYyBleGVjdXRlZCgpOiBQcm9taXNlPHN0cmluZ1tdPiB7XG4gICAgYXdhaXQgdGhpcy5lbnN1cmVTdG9yYWdlKCk7XG5cbiAgICBjb25zdCBxdWVyaWVyID0gYXdhaXQgdGhpcy5xdWVyaWVyUG9vbC5nZXRRdWVyaWVyKCk7XG5cbiAgICBpZiAoIWlzU3FsUXVlcmllcihxdWVyaWVyKSkge1xuICAgICAgYXdhaXQgcXVlcmllci5yZWxlYXNlKCk7XG4gICAgICB0aHJvdyBuZXcgRXJyb3IoJ0RhdGFiYXNlTWlncmF0aW9uU3RvcmFnZSByZXF1aXJlcyBhIFNRTC1iYXNlZCBxdWVyaWVyJyk7XG4gICAgfVxuXG4gICAgdHJ5IHtcbiAgICAgIGNvbnN0IHsgZXNjYXBlSWQgfSA9IHF1ZXJpZXIuZGlhbGVjdDtcbiAgICAgIGNvbnN0IHNxbCA9IGBTRUxFQ1QgJHtlc2NhcGVJZCgnbmFtZScpfSBGUk9NICR7ZXNjYXBlSWQodGhpcy50YWJsZU5hbWUpfSBPUkRFUiBCWSAke2VzY2FwZUlkKCduYW1lJyl9IEFTQ2A7XG4gICAgICBjb25zdCByZXN1bHRzID0gYXdhaXQgcXVlcmllci5hbGw8TWlncmF0aW9uUmVjb3JkPihzcWwpO1xuICAgICAgcmV0dXJuIHJlc3VsdHMubWFwKChyOiBhbnkpID0+IHIubmFtZSk7XG4gICAgfSBmaW5hbGx5IHtcbiAgICAgIGF3YWl0IHF1ZXJpZXIucmVsZWFzZSgpO1xuICAgIH1cbiAgfVxuXG4gIC8qKlxuICAgKiBMb2cgYSBtaWdyYXRpb24gYXMgZXhlY3V0ZWQgLSB1c2VzIHByb3ZpZGVkIHF1ZXJpZXIgKHdpdGhpbiB0cmFuc2FjdGlvbilcbiAgICovXG4gIGFzeW5jIGxvZ1dpdGhRdWVyaWVyKHF1ZXJpZXI6IFNxbFF1ZXJpZXIsIG1pZ3JhdGlvbk5hbWU6IHN0cmluZyk6IFByb21pc2U8dm9pZD4ge1xuICAgIGF3YWl0IHRoaXMuZW5zdXJlU3RvcmFnZSgpO1xuICAgIGNvbnN0IHsgZXNjYXBlSWQsIHBsYWNlaG9sZGVyIH0gPSBxdWVyaWVyLmRpYWxlY3Q7XG4gICAgY29uc3Qgc3FsID0gYElOU0VSVCBJTlRPICR7ZXNjYXBlSWQodGhpcy50YWJsZU5hbWUpfSAoJHtlc2NhcGVJZCgnbmFtZScpfSkgVkFMVUVTICgke3BsYWNlaG9sZGVyKDEpfSlgO1xuICAgIGF3YWl0IHF1ZXJpZXIucnVuKHNxbCwgW21pZ3JhdGlvbk5hbWVdKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBVbmxvZyBhIG1pZ3JhdGlvbiAtIHVzZXMgcHJvdmlkZWQgcXVlcmllciAod2l0aGluIHRyYW5zYWN0aW9uKVxuICAgKi9cbiAgYXN5bmMgdW5sb2dXaXRoUXVlcmllcihxdWVyaWVyOiBTcWxRdWVyaWVyLCBtaWdyYXRpb25OYW1lOiBzdHJpbmcpOiBQcm9taXNlPHZvaWQ+IHtcbiAgICBhd2FpdCB0aGlzLmVuc3VyZVN0b3JhZ2UoKTtcbiAgICBjb25zdCB7IGVzY2FwZUlkLCBwbGFjZWhvbGRlciB9ID0gcXVlcmllci5kaWFsZWN0O1xuICAgIGNvbnN0IHNxbCA9IGBERUxFVEUgRlJPTSAke2VzY2FwZUlkKHRoaXMudGFibGVOYW1lKX0gV0hFUkUgJHtlc2NhcGVJZCgnbmFtZScpfSA9ICR7cGxhY2Vob2xkZXIoMSl9YDtcbiAgICBhd2FpdCBxdWVyaWVyLnJ1bihzcWwsIFttaWdyYXRpb25OYW1lXSk7XG4gIH1cbn1cbiJdfQ==

package/dist/migrate/storage/index.d.ts

@@ -0,0 +1,2 @@
+export * from './databaseStorage.js';
+export * from './jsonStorage.js';

package/dist/migrate/storage/index.js

@@ -0,0 +1,3 @@
+export * from './databaseStorage.js';
+export * from './jsonStorage.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbWlncmF0ZS9zdG9yYWdlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyxrQkFBa0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZGF0YWJhc2VTdG9yYWdlLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vanNvblN0b3JhZ2UuanMnO1xuIl19

package/dist/migrate/storage/jsonStorage.d.ts

@@ -0,0 +1,15 @@
+import type { MigrationStorage, SqlQuerier } from '../../type/index.js';
+/**
+ * Stores migration state in a JSON file (useful for development/testing)
+ */
+export declare class JsonMigrationStorage implements MigrationStorage {
+    private readonly filePath;
+    private cache;
+    constructor(filePath?: string);
+    ensureStorage(): Promise<void>;
+    executed(): Promise<string[]>;
+    logWithQuerier(_querier: SqlQuerier, migrationName: string): Promise<void>;
+    unlogWithQuerier(_querier: SqlQuerier, migrationName: string): Promise<void>;
+    private load;
+    private save;
+}

package/dist/migrate/storage/jsonStorage.js

@@ -0,0 +1,51 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+/**
+ * Stores migration state in a JSON file (useful for development/testing)
+ */
+export class JsonMigrationStorage {
+    filePath;
+    cache = null;
+    constructor(filePath = './migrations/.uql-migrations.json') {
+        this.filePath = filePath;
+    }
+    async ensureStorage() {
+        try {
+            await this.load();
+        }
+        catch {
+            // File doesn't exist, create it
+            await this.save([]);
+        }
+    }
+    async executed() {
+        await this.ensureStorage();
+        return this.cache ?? [];
+    }
+    async logWithQuerier(_querier, migrationName) {
+        const executed = await this.executed();
+        if (!executed.includes(migrationName)) {
+            executed.push(migrationName);
+            executed.sort();
+            await this.save(executed);
+        }
+    }
+    async unlogWithQuerier(_querier, migrationName) {
+        const executed = await this.executed();
+        const index = executed.indexOf(migrationName);
+        if (index !== -1) {
+            executed.splice(index, 1);
+            await this.save(executed);
+        }
+    }
+    async load() {
+        const content = await readFile(this.filePath, 'utf-8');
+        this.cache = JSON.parse(content);
+    }
+    async save(migrations) {
+        await mkdir(dirname(this.filePath), { recursive: true });
+        await writeFile(this.filePath, JSON.stringify(migrations, null, 2), 'utf-8');
+        this.cache = migrations;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/migrate/type.d.ts

@@ -0,0 +1 @@
+export * from '../type/index.js';

package/dist/migrate/type.js

@@ -0,0 +1,2 @@
+export * from '../type/index.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9taWdyYXRlL3R5cGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxrQkFBa0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4uL3R5cGUvaW5kZXguanMnO1xuIl19

package/dist/mongo/index.d.ts

@@ -0,0 +1,3 @@
+export * from './mongoDialect.js';
+export * from './mongodbQuerier.js';
+export * from './mongodbQuerierPool.js';

package/dist/mongo/index.js

@@ -0,0 +1,4 @@
+export * from './mongoDialect.js';
+export * from './mongodbQuerier.js';
+export * from './mongodbQuerierPool.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbW9uZ28vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMseUJBQXlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL21vbmdvRGlhbGVjdC5qcyc7XG5leHBvcnQgKiBmcm9tICcuL21vbmdvZGJRdWVyaWVyLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vbW9uZ29kYlF1ZXJpZXJQb29sLmpzJztcbiJdfQ==

package/dist/mongo/mongoDialect.d.ts

@@ -0,0 +1,34 @@
+import { type Document, type Filter, ObjectId, type Sort } from 'mongodb';
+import { AbstractDialect } from '../dialect/index.js';
+import type { EntityMeta, FieldValue, Query, QueryOptions, QuerySelect, QuerySelectMap, QuerySort, QueryWhere, RelationKey, Type } from '../type/index.js';
+import { type CallbackKey } from '../util/index.js';
+export declare class MongoDialect extends AbstractDialect {
+    where<E extends Document>(entity: Type<E>, where?: QueryWhere<E>, { softDelete }?: QueryOptions): Filter<E>;
+    select<E extends Document>(entity: Type<E>, select: QuerySelect<E>): QuerySelectMap<E>;
+    sort<E extends Document>(entity: Type<E>, sort: QuerySort<E>): Sort;
+    aggregationPipeline<E extends Document>(entity: Type<E>, q: Query<E>): MongoAggregationPipelineEntry<E>[];
+    normalizeIds<E extends Document>(meta: EntityMeta<E>, docs: E[]): E[];
+    normalizeId<E extends Document>(meta: EntityMeta<E>, doc: E): E;
+    getIdValue<T extends IdValue>(value: T): T;
+    getPersistable<E>(meta: EntityMeta<E>, payload: E, callbackKey: CallbackKey): E;
+    getPersistables<E>(meta: EntityMeta<E>, payload: E | E[], callbackKey: CallbackKey): E[];
+}
+type MongoAggregationPipelineEntry<E extends Document> = {
+    readonly $lookup?: MongoAggregationLookup<E>;
+    $match?: Filter<E> | Record<string, any>;
+    $sort?: Sort;
+    readonly $unwind?: MongoAggregationUnwind;
+};
+type MongoAggregationLookup<E extends Document> = {
+    readonly from?: string;
+    readonly foreignField?: string;
+    readonly localField?: string;
+    readonly pipeline?: MongoAggregationPipelineEntry<FieldValue<E>>[];
+    readonly as?: RelationKey<E>;
+};
+type MongoAggregationUnwind = {
+    readonly path?: string;
+    readonly preserveNullAndEmptyArrays?: boolean;
+};
+type IdValue = string | ObjectId;
+export {};

package/dist/mongo/mongoDialect.js

@@ -0,0 +1,163 @@
+import { ObjectId } from 'mongodb';
+import { AbstractDialect } from '../dialect/index.js';
+import { getMeta } from '../entity/index.js';
+import { buildSortMap, buldQueryWhereAsMap, fillOnFields, filterFieldKeys, filterRelationKeys, getKeys, hasKeys, } from '../util/index.js';
+export class MongoDialect extends AbstractDialect {
+    where(entity, where = {}, { softDelete } = {}) {
+        const meta = getMeta(entity);
+        where = buldQueryWhereAsMap(meta, where);
+        if (meta.softDelete && (softDelete || softDelete === undefined) && !where[meta.softDelete]) {
+            const field = meta.fields[meta.softDelete];
+            where[this.resolveColumnName(meta.softDelete, field)] = null;
+        }
+        return getKeys(where).reduce((acc, key) => {
+            let value = where[key];
+            if (key === '$and' || key === '$or') {
+                acc[key] = value.map((filterIt) => this.where(entity, filterIt));
+            }
+            else {
+                const field = meta.fields[key];
+                if (key === '_id' || key === meta.id) {
+                    key = '_id';
+                    value = this.getIdValue(value);
+                }
+                else if (field) {
+                    key = this.resolveColumnName(key, field);
+                }
+                if (Array.isArray(value)) {
+                    value = {
+                        $in: value,
+                    };
+                }
+                acc[key] = value;
+            }
+            return acc;
+        }, {});
+    }
+    select(entity, select) {
+        if (Array.isArray(select)) {
+            return select.reduce((acc, it) => {
+                acc[it] = true;
+                return acc;
+            }, {});
+        }
+        return select;
+    }
+    sort(entity, sort) {
+        return buildSortMap(sort);
+    }
+    aggregationPipeline(entity, q) {
+        const meta = getMeta(entity);
+        const where = this.where(entity, q.$where);
+        const sort = this.sort(entity, q.$sort);
+        const firstPipelineEntry = {};
+        if (hasKeys(where)) {
+            firstPipelineEntry.$match = where;
+        }
+        if (hasKeys(sort)) {
+            firstPipelineEntry.$sort = sort;
+        }
+        const pipeline = [];
+        if (hasKeys(firstPipelineEntry)) {
+            pipeline.push(firstPipelineEntry);
+        }
+        const relKeys = filterRelationKeys(meta, q.$select);
+        for (const relKey of relKeys) {
+            const relOpts = meta.relations[relKey];
+            if (relOpts.cardinality === '1m' || relOpts.cardinality === 'mm') {
+                // '1m' and 'mm' should be resolved in a higher layer because they will need multiple queries
+                continue;
+            }
+            const relEntity = relOpts.entity();
+            const relMeta = getMeta(relEntity);
+            if (relOpts.cardinality === 'm1') {
+                const localField = meta.fields[relOpts.references[0].local];
+                pipeline.push({
+                    $lookup: {
+                        from: this.resolveTableName(relEntity, relMeta),
+                        localField: this.resolveColumnName(relOpts.references[0].local, localField),
+                        foreignField: '_id',
+                        as: relKey,
+                    },
+                });
+            }
+            else {
+                const foreignField = relMeta.fields[relOpts.references[0].foreign];
+                const foreignFieldName = this.resolveColumnName(relOpts.references[0].foreign, foreignField);
+                const referenceWhere = this.where(relEntity, where);
+                const referenceSort = this.sort(relEntity, q.$sort);
+                const referencePipelineEntry = {
+                    $match: { [foreignFieldName]: referenceWhere._id },
+                };
+                if (hasKeys(referenceSort)) {
+                    referencePipelineEntry.$sort = referenceSort;
+                }
+                pipeline.push({
+                    $lookup: {
+                        from: this.resolveTableName(relEntity, relMeta),
+                        pipeline: [referencePipelineEntry],
+                        as: relKey,
+                    },
+                });
+            }
+            pipeline.push({ $unwind: { path: `$${relKey}`, preserveNullAndEmptyArrays: true } });
+        }
+        return pipeline;
+    }
+    normalizeIds(meta, docs) {
+        return docs?.map((doc) => this.normalizeId(meta, doc));
+    }
+    normalizeId(meta, doc) {
+        if (!doc) {
+            return;
+        }
+        const res = doc;
+        if (res._id) {
+            res[meta.id] = res._id;
+            if (meta.id !== '_id') {
+                delete res._id;
+            }
+        }
+        for (const key of getKeys(meta.fields)) {
+            const field = meta.fields[key];
+            const dbName = this.resolveColumnName(key, field);
+            if (dbName !== key && res[dbName] !== undefined) {
+                res[key] = res[dbName];
+                delete res[dbName];
+            }
+        }
+        const relKeys = getKeys(meta.relations).filter((key) => res[key]);
+        for (const relKey of relKeys) {
+            const relOpts = meta.relations[relKey];
+            const relMeta = getMeta(relOpts.entity());
+            res[relKey] = Array.isArray(res[relKey])
+                ? this.normalizeIds(relMeta, res[relKey])
+                : this.normalizeId(relMeta, res[relKey]);
+        }
+        return res;
+    }
+    getIdValue(value) {
+        if (value instanceof ObjectId) {
+            return value;
+        }
+        try {
+            return new ObjectId(value);
+        }
+        catch (e) {
+            return value;
+        }
+    }
+    getPersistable(meta, payload, callbackKey) {
+        return this.getPersistables(meta, payload, callbackKey)[0];
+    }
+    getPersistables(meta, payload, callbackKey) {
+        const payloads = fillOnFields(meta, payload, callbackKey);
+        const persistableKeys = filterFieldKeys(meta, payloads[0], callbackKey);
+        return payloads.map((it) => persistableKeys.reduce((acc, key) => {
+            const field = meta.fields[key];
+            acc[this.resolveColumnName(key, field)] = it[key];
+            return acc;
+        }, {}));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mongoDialect.js","sourceRoot":"","sources":["../../src/mongo/mongoDialect.ts"],"names":[],"mappings":"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","sourcesContent":["import { type Document, type Filter, ObjectId, type Sort } from 'mongodb';\nimport { AbstractDialect } from '../dialect/index.js';\nimport { getMeta } from '../entity/index.js';\nimport type {\n  EntityMeta,\n  FieldValue,\n  Query,\n  QueryOptions,\n  QuerySelect,\n  QuerySelectMap,\n  QuerySort,\n  QueryWhere,\n  RelationKey,\n  Type,\n} from '../type/index.js';\nimport {\n  buildSortMap,\n  buldQueryWhereAsMap,\n  type CallbackKey,\n  fillOnFields,\n  filterFieldKeys,\n  filterRelationKeys,\n  getKeys,\n  hasKeys,\n} from '../util/index.js';\n\nexport class MongoDialect extends AbstractDialect {\n  where<E extends Document>(entity: Type<E>, where: QueryWhere<E> = {}, { softDelete }: QueryOptions = {}): Filter<E> {\n    const meta = getMeta(entity);\n\n    where = buldQueryWhereAsMap(meta, where);\n\n    if (meta.softDelete && (softDelete || softDelete === undefined) && !where[meta.softDelete]) {\n      const field = meta.fields[meta.softDelete];\n      where[this.resolveColumnName(meta.softDelete, field)] = null;\n    }\n\n    return getKeys(where).reduce(\n      (acc, key) => {\n        let value = where[key];\n        if (key === '$and' || key === '$or') {\n          acc[key] = value.map((filterIt: QueryWhere<E>) => this.where(entity, filterIt));\n        } else {\n          const field = meta.fields[key];\n          if (key === '_id' || key === meta.id) {\n            key = '_id';\n            value = this.getIdValue(value);\n          } else if (field) {\n            key = this.resolveColumnName(key, field);\n          }\n          if (Array.isArray(value)) {\n            value = {\n              $in: value,\n            };\n          }\n          acc[key as keyof Filter<E>] = value;\n        }\n        return acc;\n      },\n      {} as Filter<E>,\n    );\n  }\n\n  select<E extends Document>(entity: Type<E>, select: QuerySelect<E>): QuerySelectMap<E> {\n    if (Array.isArray(select)) {\n      return select.reduce(\n        (acc, it) => {\n          acc[it as string] = true;\n          return acc;\n        },\n        {} satisfies QuerySelectMap<E>,\n      );\n    }\n    return select as QuerySelectMap<E>;\n  }\n\n  sort<E extends Document>(entity: Type<E>, sort: QuerySort<E>): Sort {\n    return buildSortMap(sort) as Sort;\n  }\n\n  aggregationPipeline<E extends Document>(entity: Type<E>, q: Query<E>): MongoAggregationPipelineEntry<E>[] {\n    const meta = getMeta(entity);\n\n    const where = this.where(entity, q.$where);\n    const sort = this.sort(entity, q.$sort);\n    const firstPipelineEntry: MongoAggregationPipelineEntry<E> = {};\n\n    if (hasKeys(where)) {\n      firstPipelineEntry.$match = where;\n    }\n    if (hasKeys(sort)) {\n      firstPipelineEntry.$sort = sort;\n    }\n\n    const pipeline: MongoAggregationPipelineEntry<E>[] = [];\n\n    if (hasKeys(firstPipelineEntry)) {\n      pipeline.push(firstPipelineEntry);\n    }\n\n    const relKeys = filterRelationKeys(meta, q.$select);\n\n    for (const relKey of relKeys) {\n      const relOpts = meta.relations[relKey];\n\n      if (relOpts.cardinality === '1m' || relOpts.cardinality === 'mm') {\n        // '1m' and 'mm' should be resolved in a higher layer because they will need multiple queries\n        continue;\n      }\n\n      const relEntity = relOpts.entity();\n      const relMeta = getMeta(relEntity);\n\n      if (relOpts.cardinality === 'm1') {\n        const localField = meta.fields[relOpts.references[0].local];\n        pipeline.push({\n          $lookup: {\n            from: this.resolveTableName(relEntity, relMeta),\n            localField: this.resolveColumnName(relOpts.references[0].local, localField),\n            foreignField: '_id',\n            as: relKey,\n          },\n        });\n      } else {\n        const foreignField = relMeta.fields[relOpts.references[0].foreign];\n        const foreignFieldName = this.resolveColumnName(relOpts.references[0].foreign, foreignField);\n        const referenceWhere = this.where(relEntity, where);\n        const referenceSort = this.sort(relEntity, q.$sort);\n        const referencePipelineEntry: MongoAggregationPipelineEntry<FieldValue<E>> = {\n          $match: { [foreignFieldName]: referenceWhere._id },\n        };\n        if (hasKeys(referenceSort)) {\n          referencePipelineEntry.$sort = referenceSort;\n        }\n        pipeline.push({\n          $lookup: {\n            from: this.resolveTableName(relEntity, relMeta),\n            pipeline: [referencePipelineEntry],\n            as: relKey,\n          },\n        });\n      }\n\n      pipeline.push({ $unwind: { path: `$${relKey}`, preserveNullAndEmptyArrays: true } });\n    }\n\n    return pipeline;\n  }\n\n  normalizeIds<E extends Document>(meta: EntityMeta<E>, docs: E[]): E[] {\n    return docs?.map((doc) => this.normalizeId(meta, doc));\n  }\n\n  normalizeId<E extends Document>(meta: EntityMeta<E>, doc: E): E {\n    if (!doc) {\n      return;\n    }\n\n    const res = doc as any;\n\n    if (res._id) {\n      res[meta.id] = res._id;\n      if (meta.id !== '_id') {\n        delete res._id;\n      }\n    }\n\n    for (const key of getKeys(meta.fields)) {\n      const field = meta.fields[key];\n      const dbName = this.resolveColumnName(key, field);\n      if (dbName !== key && res[dbName] !== undefined) {\n        res[key] = res[dbName];\n        delete res[dbName];\n      }\n    }\n\n    const relKeys = getKeys(meta.relations).filter((key) => res[key]) as RelationKey<E>[];\n\n    for (const relKey of relKeys) {\n      const relOpts = meta.relations[relKey];\n      const relMeta = getMeta(relOpts.entity());\n      res[relKey] = Array.isArray(res[relKey])\n        ? this.normalizeIds(relMeta, res[relKey])\n        : this.normalizeId(relMeta, res[relKey]);\n    }\n\n    return res;\n  }\n\n  getIdValue<T extends IdValue>(value: T): T {\n    if (value instanceof ObjectId) {\n      return value;\n    }\n    try {\n      return new ObjectId(value) as T;\n    } catch (e) {\n      return value;\n    }\n  }\n\n  getPersistable<E>(meta: EntityMeta<E>, payload: E, callbackKey: CallbackKey): E {\n    return this.getPersistables(meta, payload, callbackKey)[0];\n  }\n\n  getPersistables<E>(meta: EntityMeta<E>, payload: E | E[], callbackKey: CallbackKey): E[] {\n    const payloads = fillOnFields(meta, payload, callbackKey);\n    const persistableKeys = filterFieldKeys(meta, payloads[0], callbackKey);\n    return payloads.map((it) =>\n      persistableKeys.reduce((acc, key) => {\n        const field = meta.fields[key];\n        acc[this.resolveColumnName(key, field)] = it[key];\n        return acc;\n      }, {} as E),\n    );\n  }\n}\n\ntype MongoAggregationPipelineEntry<E extends Document> = {\n  readonly $lookup?: MongoAggregationLookup<E>;\n  $match?: Filter<E> | Record<string, any>;\n  $sort?: Sort;\n  readonly $unwind?: MongoAggregationUnwind;\n};\n\ntype MongoAggregationLookup<E extends Document> = {\n  readonly from?: string;\n  readonly foreignField?: string;\n  readonly localField?: string;\n  readonly pipeline?: MongoAggregationPipelineEntry<FieldValue<E>>[];\n  readonly as?: RelationKey<E>;\n};\n\ntype MongoAggregationUnwind = {\n  readonly path?: string;\n  readonly preserveNullAndEmptyArrays?: boolean;\n};\n\ntype IdValue = string | ObjectId;\n"]}

package/dist/mongo/mongodbQuerier.d.ts

@@ -0,0 +1,28 @@
+import type { Document, MongoClient } from 'mongodb';
+import { AbstractQuerier } from '../querier/index.js';
+import type { ExtraOptions, IdValue, Query, QueryConflictPaths, QueryOptions, QuerySearch, Type } from '../type/index.js';
+import type { MongoDialect } from './mongoDialect.js';
+export declare class MongodbQuerier extends AbstractQuerier {
+    readonly dialect: MongoDialect;
+    readonly conn: MongoClient;
+    readonly extra?: ExtraOptions;
+    private session;
+    constructor(dialect: MongoDialect, conn: MongoClient, extra?: ExtraOptions);
+    private execute;
+    findMany<E extends Document>(entity: Type<E>, q: Query<E>): Promise<E[]>;
+    count<E extends Document>(entity: Type<E>, qm?: QuerySearch<E>): Promise<number>;
+    insertMany<E extends Document>(entity: Type<E>, payloads: E[]): Promise<IdValue<E>[]>;
+    updateMany<E extends Document>(entity: Type<E>, qm: QuerySearch<E>, payload: E): Promise<number>;
+    upsertOne<E extends Document>(entity: Type<E>, conflictPaths: QueryConflictPaths<E>, payload: E): Promise<{
+        firstId: string;
+        changes: number;
+    }>;
+    deleteMany<E extends Document>(entity: Type<E>, qm: QuerySearch<E>, opts?: QueryOptions): Promise<number>;
+    get hasOpenTransaction(): boolean;
+    collection<E extends Document>(entity: Type<E>): import("mongodb").Collection<E>;
+    get db(): import("mongodb").Db;
+    beginTransaction(): Promise<void>;
+    commitTransaction(): Promise<void>;
+    rollbackTransaction(): Promise<void>;
+    internalRelease(): Promise<void>;
+}