@simplysm/sd-cli 7.3.4 → 10.0.21

package/dist/sd-orm-common/src/DbContext.mjs

@@ -0,0 +1,635 @@
+import { QueryBuilder } from "./QueryBuilder";
+import { QueryHelper } from "./QueryHelper";
+import { DateTime, NeverEntryError, ObjectUtil, SdError } from "@simplysm/sd-core-common";
+import { Queryable } from "./Queryable";
+import { SystemMigration } from "./models/SystemMigration";
+import { DbDefinitionUtil } from "./utils/DbDefinitionUtil";
+export class DbContext {
+    getTableDefinitions() {
+        return Object.values(this)
+            .ofType(Queryable)
+            .map(qr => qr.tableDef)
+            .filterExists();
+    }
+    // noinspection TypeScriptAbstractClassConstructorCanBeMadeProtected
+    constructor(_executor, opt) {
+        this._executor = _executor;
+        this.opt = opt;
+        // public static readonly SELECT_CACHE_TIMEOUT = 1000;
+        // public static readonly selectCache = new Map<string, { result: any[]; timeout: any } | undefined>();
+        this.status = "ready";
+        this.prepareDefs = [];
+        this.qb = new QueryBuilder(this.opt.dialect);
+        this.qh = new QueryHelper(this.opt.dialect);
+        this.systemMigration = new Queryable(this, SystemMigration);
+    }
+    async connectWithoutTransactionAsync(callback) {
+        if (!this._executor)
+            throw new Error("DB 실행기를 알 수 없습니다.");
+        await this._executor.connectAsync();
+        this.status = "connect";
+        this.lastConnectionDateTime = new DateTime();
+        let result;
+        try {
+            result = await callback();
+        }
+        catch (err) {
+            await this._executor.closeAsync();
+            this.status = "ready";
+            this.lastConnectionDateTime = undefined;
+            throw err;
+        }
+        await this._executor.closeAsync();
+        this.status = "ready";
+        this.lastConnectionDateTime = undefined;
+        return result;
+    }
+    async connectAsync(fn, isolationLevel) {
+        if (!this._executor)
+            throw new Error("DB 실행기를 알 수 없습니다.");
+        await this._executor.connectAsync();
+        this.status = "connect";
+        this.lastConnectionDateTime = new DateTime();
+        await this._executor.beginTransactionAsync(isolationLevel);
+        this.status = "transact";
+        let result;
+        try {
+            result = await fn();
+            await this._executor.commitTransactionAsync();
+            this.status = "connect";
+            this.lastConnectionDateTime = new DateTime();
+        }
+        catch (err) {
+            try {
+                await this._executor.rollbackTransactionAsync();
+                this.status = "connect";
+                this.lastConnectionDateTime = new DateTime();
+            }
+            catch (err1) {
+                if (!(err1 instanceof Error))
+                    throw new NeverEntryError();
+                if (!err1.message.includes("ROLLBACK") || !err1.message.includes("BEGIN")) {
+                    await this._executor.closeAsync();
+                    this.status = "ready";
+                    this.lastConnectionDateTime = undefined;
+                    throw err1;
+                }
+            }
+            await this._executor.closeAsync();
+            this.status = "ready";
+            this.lastConnectionDateTime = undefined;
+            throw err;
+        }
+        await this._executor.closeAsync();
+        this.status = "ready";
+        this.lastConnectionDateTime = undefined;
+        return result;
+    }
+    async transAsync(fn, isolationLevel) {
+        if (!this._executor)
+            throw new Error("DB 실행기를 알 수 없습니다.");
+        if (this.status === "transact") {
+            throw new Error("이미 TRANSACTION 상태 입니다.");
+        }
+        await this._executor.beginTransactionAsync(isolationLevel);
+        this.status = "transact";
+        let result;
+        try {
+            result = await fn();
+            await this._executor.commitTransactionAsync();
+            this.status = "connect";
+            this.lastConnectionDateTime = new DateTime();
+        }
+        catch (err) {
+            try {
+                await this._executor.rollbackTransactionAsync();
+                this.status = "connect";
+                this.lastConnectionDateTime = new DateTime();
+            }
+            catch (err1) {
+                if (!(err1 instanceof Error))
+                    throw new NeverEntryError();
+                if (!err1.message.includes("ROLLBACK") || !err1.message.includes("BEGIN")) {
+                    await this._executor.closeAsync();
+                    this.status = "ready";
+                    this.lastConnectionDateTime = undefined;
+                    throw err1;
+                }
+            }
+            await this._executor.closeAsync();
+            this.status = "ready";
+            this.lastConnectionDateTime = undefined;
+            throw err;
+        }
+        return result;
+    }
+    async executeDefsAsync(defs, options) {
+        if (!this._executor)
+            throw new Error("DB 실행기를 알 수 없습니다.");
+        return await this._executor.executeDefsAsync(defs, options);
+    }
+    async executeQueriesAsync(queries) {
+        if (!this._executor)
+            throw new Error("DB 실행기를 알 수 없습니다.");
+        return await this._executor.executeAsync(queries);
+    }
+    async bulkInsertAsync(tableName, columnDefs, records) {
+        if (!this._executor)
+            throw new Error("DB 실행기를 알 수 없습니다.");
+        await this._executor.bulkInsertAsync(tableName, columnDefs, records);
+    }
+    async executePreparedAsync() {
+        if (this.prepareDefs.length < 1)
+            return;
+        await this.executeDefsAsync(this.prepareDefs);
+        this.prepareDefs = [];
+        // DbContext.selectCache.clear();
+    }
+    async getIsDbExistsAsync(database) {
+        if (this.opt.dialect !== "sqlite") {
+            if (database === undefined)
+                throw new NeverEntryError();
+            return (await this.executeDefsAsync([
+                {
+                    type: "getDatabaseInfo",
+                    database
+                }
+            ]))[0].length > 0;
+        }
+        else {
+            throw new Error("sqlite 미구현");
+        }
+    }
+    async getIsTableExistsAsync(tableNameDef) {
+        return (await this.executeDefsAsync([
+            {
+                type: "getTableInfo",
+                table: tableNameDef
+            }
+        ]))[0].length > 0;
+    }
+    get tableDefs() {
+        return Object.keys(this)
+            .filter((key) => !key.startsWith("_"))
+            .map((key) => this[key])
+            .ofType(Queryable)
+            .map((qr) => DbDefinitionUtil.getTableDef(qr.tableType))
+            .filterExists();
+    }
+    async getTableInfosAsync(database, schema) {
+        return (await this.executeDefsAsync([{
+                type: "getTableInfos",
+                database,
+                schema
+            }]))[0].map((item) => ({
+            schema: item.TABLE_SCHEMA,
+            name: item.TABLE_NAME
+        }));
+    }
+    async getTableColumnInfosAsync(database, schema, table) {
+        return (await this.executeDefsAsync([
+            {
+                type: "getTableColumnInfos",
+                table: { database, schema, name: table }
+            }
+        ]))[0].map((item) => ({
+            name: item.name,
+            dataType: item.dataType,
+            length: item.length,
+            precision: item.precision,
+            digits: item.digits,
+            nullable: item.nullable,
+            autoIncrement: item.autoIncrement
+        }));
+    }
+    async getTablePkColumnNamesAsync(database, schema, table) {
+        return (await this.executeDefsAsync([
+            {
+                type: "getTablePrimaryKeys",
+                table: { database, schema, name: table }
+            }
+        ]))[0].map((item) => item.name);
+    }
+    async getTableFksAsync(database, schema, table) {
+        return (await this.executeDefsAsync([
+            {
+                type: "getTableForeignKeys",
+                table: { database, schema, name: table }
+            }
+        ]))[0]
+            .groupBy((item) => item.name)
+            .map((item) => ({
+            name: item.key,
+            sourceColumnNames: item.values.map((item1) => item1.sourceColumnName),
+            targetSchemaName: item.values[0].targetSchemaName,
+            targetTableName: item.values[0].targetTableName
+        }));
+    }
+    async getTableIndexesAsync(database, schema, table) {
+        return (await this.executeDefsAsync([
+            {
+                type: "getTableIndexes",
+                table: { database, schema, name: table }
+            }
+        ]))[0]
+            .groupBy((item) => item.name)
+            .map((item) => ({
+            name: item.key,
+            columns: item.values.map((item1) => ({
+                name: item1.columnName,
+                orderBy: item1.isDesc === true ? "DESC" : "ASC"
+            }))
+        }));
+    }
+    async truncateTable(table) {
+        await this.executeDefsAsync([{
+                type: "truncateTable",
+                table: {
+                    ...this.opt.dialect === "sqlite" ? {} : {
+                        database: this.opt.database,
+                        schema: this.opt.schema,
+                    },
+                    name: table
+                }
+            }]);
+    }
+    async initializeAsync(dbs, force) {
+        if (force && this.status === "transact") {
+            throw new Error("DB 강제 초기화는 트랜젝션 상에서는 동작하지 못합니다.\nconnect 대신에 connectWithoutTransaction 로 연결하여 시도하세요.");
+        }
+        if (force && this.opt.dialect === "sqlite") {
+            throw new Error("sqlite 강제초기화 불가, 강제로 초기화 하려면, 데이터베이스 파일을 삭제하고 초기화를 수행하세요.");
+        }
+        // 강제 아닐때
+        if (!force) {
+            const isDbExists = this.opt.dialect === "sqlite" ? true : await this.getIsDbExistsAsync(this.opt.database);
+            const isMigrationTableExists = !isDbExists ? false : await this.getIsTableExistsAsync({
+                ...this.opt.dialect === "sqlite" ? {} : {
+                    database: this.opt.database,
+                    schema: this.opt.schema,
+                },
+                name: "_migration"
+            });
+            // DB / Migration TABLE 있을때
+            if (isDbExists && isMigrationTableExists) {
+                const dbMigrationCodes = (await this.systemMigration
+                    .select((item) => ({
+                    code: item.code
+                }))
+                    .resultAsync()).map((item) => item.code);
+                const migrations = this.migrations
+                    .filter((item) => !dbMigrationCodes.includes(item.name))
+                    .orderBy((item) => item.name);
+                // 마이그레이션 있을때
+                if (migrations.length > 0) {
+                    if (this.status !== "transact") {
+                        await this.transAsync(async () => {
+                            for (const migration of migrations) {
+                                await new migration().up(this);
+                                await this.systemMigration.insertAsync([{
+                                        code: migration.name
+                                    }]);
+                            }
+                        });
+                    }
+                    else {
+                        for (const migration of migrations) {
+                            await new migration().up(this);
+                            await this.systemMigration.insertAsync([{
+                                    code: migration.name
+                                }]);
+                        }
+                    }
+                    return true;
+                }
+                else {
+                    return false;
+                }
+            }
+        }
+        // 강제 혹은 첫 수행
+        let tableDefs;
+        if (this.opt.dialect !== "sqlite") {
+            const dbNames = dbs ?? (this.opt.database !== undefined ? [this.opt.database] : []);
+            if (dbNames.length < 1) {
+                throw new Error("생성할 데이터베이스가 없습니다.");
+            }
+            // DB 초기화
+            for (const dbName of dbNames) {
+                await this.executeDefsAsync([{
+                        type: "createDatabaseIfNotExists",
+                        database: dbName
+                    }]);
+                await this.executeQueriesAsync([`USE ${dbName};`]);
+                await this.executeDefsAsync([{
+                        type: "clearDatabaseIfExists",
+                        database: dbName
+                    }]);
+            }
+            await this.executeQueriesAsync([`USE ${this.opt.database};`]);
+            // TABLE 초기화: 생성/PK 설정
+            tableDefs = this.tableDefs
+                .filter((item) => item.database === undefined || dbNames.includes(item.database))
+                .filterExists();
+        }
+        else {
+            tableDefs = this.tableDefs.filterExists();
+        }
+        const queryDefsList = [];
+        queryDefsList.push(...this.getCreateTablesFullQueryDefsFromTableDef(tableDefs));
+        // Migration 데이터 저장 등록
+        const migrationInsertQueryDefs = [];
+        for (const migration of this.migrations.orderBy((item) => item.name)) {
+            migrationInsertQueryDefs.push({
+                type: "insert",
+                from: this.qb.getTableName({
+                    ...this.opt.dialect === "sqlite" ? {} : {
+                        database: this.opt.database,
+                        schema: this.opt.schema
+                    },
+                    name: "_migration"
+                }),
+                record: {
+                    [this.qb.wrap("code")]: `N'${migration.name}'`
+                }
+            });
+        }
+        queryDefsList.push(migrationInsertQueryDefs);
+        for (const queryDefs of queryDefsList) {
+            await this.executeDefsAsync(queryDefs);
+        }
+        return true;
+    }
+    getCreateTablesFullQueryDefsFromTableDef(tableDefs) {
+        const result = [];
+        const createTableQueryDefs = [];
+        for (const tableDef of tableDefs) {
+            createTableQueryDefs.push(this.getCreateTableQueryDefFromTableDef(tableDef));
+        }
+        result.push(createTableQueryDefs);
+        // TABLE 초기화: FK 설정
+        const addFkQueryDefs = [];
+        for (const tableDef of tableDefs) {
+            addFkQueryDefs.push(...this.getCreateFksQueryDefsFromTableDef(tableDef));
+        }
+        result.push(addFkQueryDefs);
+        // TABLE 초기화: INDEX 설정
+        const createIndexQueryDefs = [];
+        for (const tableDef of tableDefs) {
+            createIndexQueryDefs.push(...this.getCreateIndexesQueryDefsFromTableDef(tableDef));
+        }
+        result.push(createIndexQueryDefs);
+        return result;
+    }
+    getCreateTableQueryDefFromTableDef(tableDef) {
+        if (tableDef.columns.length < 1) {
+            throw new Error(`'${tableDef.name}'의 컬럼 설정이 잘못되었습니다.`);
+        }
+        if (!tableDef.view) {
+            return {
+                type: "createTable",
+                table: this.getTableNameDef(tableDef),
+                columns: tableDef.columns.map((col) => ObjectUtil.clearUndefined({
+                    name: col.name,
+                    dataType: this.qh.type(col.dataType ?? col.typeFwd()),
+                    autoIncrement: col.autoIncrement,
+                    nullable: col.nullable
+                })),
+                primaryKeys: tableDef.columns
+                    .filter((item) => item.primaryKey !== undefined)
+                    .orderBy((item) => item.primaryKey)
+                    .map((item) => ({
+                    columnName: item.name,
+                    orderBy: "ASC"
+                }))
+            };
+        }
+        else {
+            return {
+                type: "createView",
+                table: this.getTableNameDef(tableDef),
+                queryDef: tableDef.view(this).getSelectQueryDef()
+            };
+        }
+    }
+    getCreateFksQueryDefsFromTableDef(tableDef) {
+        if (tableDef.columns.length < 1) {
+            throw new Error(`'${tableDef.name}'의 컬럼 설정이 잘못되었습니다.`);
+        }
+        const addFkQueryDefs = [];
+        for (const fkDef of tableDef.foreignKeys) {
+            try {
+                const targetTableDef = DbDefinitionUtil.getTableDef(fkDef.targetTypeFwd());
+                if (targetTableDef.columns.length < 1) {
+                    throw new Error(`${targetTableDef.name}의 컬럼 설정이 잘못되었습니다.`);
+                }
+                const targetPkNames = targetTableDef.columns
+                    .filter((item) => item.primaryKey !== undefined)
+                    .orderBy((item) => item.primaryKey)
+                    .map((item) => item.name);
+                addFkQueryDefs.push(...[
+                    {
+                        type: "addForeignKey",
+                        table: this.getTableNameDef(tableDef),
+                        foreignKey: {
+                            name: fkDef.name,
+                            fkColumns: fkDef.columnPropertyKeys.map((propKey) => tableDef.columns.single((col) => col.propertyKey === propKey).name),
+                            targetTable: this.getTableNameDef(targetTableDef),
+                            targetPkColumns: targetPkNames
+                        }
+                    },
+                    {
+                        type: "createIndex",
+                        table: this.getTableNameDef(tableDef),
+                        index: {
+                            name: fkDef.name,
+                            columns: fkDef.columnPropertyKeys.map((item) => ({
+                                name: tableDef.columns.single((col) => col.propertyKey === item).name,
+                                orderBy: "ASC",
+                                unique: false
+                            }))
+                        }
+                    }
+                ]);
+            }
+            catch (err) {
+                if (err instanceof Error) {
+                    throw new SdError(err, tableDef.name + " > " + fkDef.name + ": 오류");
+                }
+                else {
+                    throw err;
+                }
+            }
+        }
+        return addFkQueryDefs;
+    }
+    getCreateIndexesQueryDefsFromTableDef(tableDef) {
+        if (tableDef.columns.length < 1) {
+            throw new Error(`'${tableDef.name}'의 컬럼 설정이 잘못되었습니다.`);
+        }
+        const createIndexQueryDefs = [];
+        for (const indexDef of tableDef.indexes) {
+            createIndexQueryDefs.push({
+                type: "createIndex",
+                table: this.getTableNameDef(tableDef),
+                index: {
+                    name: indexDef.name,
+                    columns: indexDef.columns.orderBy((item) => item.order).map((item) => ({
+                        name: tableDef.columns.single((col) => col.propertyKey === item.columnPropertyKey).name,
+                        orderBy: item.orderBy,
+                        unique: item.unique
+                    }))
+                }
+            });
+        }
+        return createIndexQueryDefs;
+    }
+    getAddColumnQueryDefFromTableDef(tableDef, columnName) {
+        if (tableDef.columns.length < 1) {
+            throw new Error(`'${tableDef.name}'의 컬럼 설정이 잘못되었습니다.`);
+        }
+        const columnDef = tableDef.columns.single((col) => col.name === columnName);
+        if (!columnDef) {
+            throw new Error(`'${tableDef.name}.${columnName}' 설정이 잘못되었습니다.`);
+        }
+        return {
+            type: "addColumn",
+            table: this.getTableNameDef(tableDef),
+            column: {
+                name: columnDef.name,
+                dataType: this.qh.type(columnDef.dataType ?? columnDef.typeFwd()),
+                autoIncrement: columnDef.autoIncrement,
+                nullable: columnDef.nullable
+            }
+        };
+    }
+    getModifyColumnQueryDefFromTableDef(tableDef, columnName) {
+        if (tableDef.columns.length < 1) {
+            throw new Error(`'${tableDef.name}'의 컬럼 설정이 잘못되었습니다.`);
+        }
+        const columnDef = tableDef.columns.single((col) => col.name === columnName);
+        if (!columnDef) {
+            throw new Error(`'${tableDef.name}.${columnName}' 설정이 잘못되었습니다.`);
+        }
+        return {
+            type: "modifyColumn",
+            table: this.getTableNameDef(tableDef),
+            column: {
+                name: columnDef.name,
+                dataType: this.qh.type(columnDef.dataType ?? columnDef.typeFwd()),
+                autoIncrement: columnDef.autoIncrement,
+                nullable: columnDef.nullable
+            }
+        };
+    }
+    getModifyPkQueryDefFromTableDef(tableDef, columnNames) {
+        if (tableDef.columns.length < 1) {
+            throw new Error(`'${tableDef.name}'의 컬럼 설정이 잘못되었습니다.`);
+        }
+        return [
+            {
+                type: "dropPrimaryKey",
+                table: this.getTableNameDef(tableDef)
+            },
+            ...(columnNames.length > 0) ? [
+                {
+                    type: "addPrimaryKey",
+                    table: this.getTableNameDef(tableDef),
+                    columns: columnNames
+                }
+            ] : []
+        ];
+    }
+    getAddFkQueryDefFromTableDef(tableDef, fkName) {
+        if (tableDef.columns.length < 1) {
+            throw new Error(`'${tableDef.name}'의 컬럼 설정이 잘못되었습니다.`);
+        }
+        const fkDef = tableDef.foreignKeys.single((col) => col.name === fkName);
+        if (!fkDef) {
+            throw new Error(`'${tableDef.name} => FK: ${fkName}' 설정이 잘못되었습니다.`);
+        }
+        const targetTableDef = DbDefinitionUtil.getTableDef(fkDef.targetTypeFwd());
+        if (targetTableDef.columns.length < 1) {
+            throw new Error(`${targetTableDef.name}의 컬럼 설정이 잘못되었습니다.`);
+        }
+        const targetPkNames = targetTableDef.columns
+            .filter((item) => item.primaryKey !== undefined)
+            .orderBy((item) => item.primaryKey)
+            .map((item) => item.name);
+        return {
+            type: "addForeignKey",
+            table: this.getTableNameDef(tableDef),
+            foreignKey: {
+                name: fkDef.name,
+                fkColumns: fkDef.columnPropertyKeys.map((propKey) => tableDef.columns.single((col) => col.propertyKey === propKey).name),
+                targetTable: this.getTableNameDef(targetTableDef),
+                targetPkColumns: targetPkNames
+            }
+        };
+    }
+    getRemoveFkQueryDefFromTableDef(tableDef, fkName) {
+        if (tableDef.columns.length < 1) {
+            throw new Error(`'${tableDef.name}'의 컬럼 설정이 잘못되었습니다.`);
+        }
+        return {
+            type: "removeForeignKey",
+            table: this.getTableNameDef(tableDef),
+            foreignKey: fkName
+        };
+    }
+    getCreateIndexQueryDefFromTableDef(tableDef, indexName) {
+        if (tableDef.columns.length < 1) {
+            throw new Error(`'${tableDef.name}'의 컬럼 설정이 잘못되었습니다.`);
+        }
+        let indexDef = tableDef.indexes.single((item) => item.name === indexName);
+        if (!indexDef) {
+            const fkDef = tableDef.foreignKeys.single((item) => item.name === indexName);
+            if (!fkDef) {
+                throw new Error(`'${tableDef.name} => IDX: ${indexName}' 설정이 잘못되었습니다.`);
+            }
+            indexDef = {
+                name: fkDef.name,
+                description: fkDef.description,
+                columns: fkDef.columnPropertyKeys.map((propKey, i) => ({
+                    columnPropertyKey: propKey,
+                    name: tableDef.columns.single((col) => col.propertyKey === propKey).name,
+                    order: i + 1,
+                    orderBy: "ASC",
+                    unique: false
+                }))
+            };
+        }
+        return {
+            type: "createIndex",
+            table: this.getTableNameDef(tableDef),
+            index: {
+                name: indexDef.name,
+                columns: indexDef.columns.orderBy((item) => item.order).map((item) => ({
+                    name: tableDef.columns.single((col) => col.propertyKey === item.columnPropertyKey).name,
+                    orderBy: item.orderBy,
+                    unique: item.unique
+                }))
+            }
+        };
+    }
+    getDropIndexQueryDefFromTableDef(tableDef, indexName) {
+        if (tableDef.columns.length < 1) {
+            throw new Error(`'${tableDef.name}'의 컬럼 설정이 잘못되었습니다.`);
+        }
+        return {
+            type: "dropIndex",
+            table: this.getTableNameDef(tableDef),
+            index: indexName
+        };
+    }
+    getTableNameDef(tableDef) {
+        return {
+            ...this.opt.dialect === "sqlite" ? {} : {
+                database: tableDef.database ?? this.opt.database,
+                schema: tableDef.schema ?? this.opt.schema
+            },
+            name: tableDef.name
+        };
+    }
+}
+//# sourceMappingURL=DbContext.js.map

package/dist/sd-orm-common/src/IDbConnection.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import { EventEmitter } from "events";
+import { IQueryColumnDef, ISOLATION_LEVEL, TDbConnectionConfig } from "./commons";
+export interface IDbConnection extends EventEmitter {
+    config: TDbConnectionConfig;
+    isConnected: boolean;
+    isOnTransaction: boolean;
+    connectAsync(): Promise<void>;
+    closeAsync(): Promise<void>;
+    beginTransactionAsync(isolationLevel?: ISOLATION_LEVEL): Promise<void>;
+    commitTransactionAsync(): Promise<void>;
+    rollbackTransactionAsync(): Promise<void>;
+    executeAsync(queries: string[]): Promise<any[][]>;
+    bulkInsertAsync(tableName: string, columnDefs: IQueryColumnDef[], records: Record<string, any>[]): Promise<void>;
+}

package/dist/sd-orm-common/src/IDbConnection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IDbConnection.js","sourceRoot":"","sources":["../../../../sd-orm-common/src/IDbConnection.ts"],"names":[],"mappings":""}

package/dist/sd-orm-common/src/IDbConnection.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IDbConnection.js.map

package/dist/sd-orm-common/src/IDbContextExecutor.d.ts

@@ -0,0 +1,17 @@
+import { IQueryColumnDef, IQueryResultParseOption, ISOLATION_LEVEL, TQueryDef } from "./commons";
+import { TDbContextOption } from "./DbContext";
+export interface IDbContextExecutor {
+    getInfoAsync(): Promise<{
+        dialect: TDbContextOption["dialect"];
+        database?: string;
+        schema?: string;
+    }>;
+    connectAsync(): Promise<void>;
+    beginTransactionAsync(isolationLevel?: ISOLATION_LEVEL): Promise<void>;
+    commitTransactionAsync(): Promise<void>;
+    rollbackTransactionAsync(): Promise<void>;
+    executeDefsAsync(defs: TQueryDef[], options?: (IQueryResultParseOption | undefined)[]): Promise<any[][]>;
+    executeAsync(queries: string[]): Promise<any[][]>;
+    bulkInsertAsync(tableName: string, columnDefs: IQueryColumnDef[], records: Record<string, any>[]): Promise<void>;
+    closeAsync(): Promise<void>;
+}

package/dist/sd-orm-common/src/IDbContextExecutor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IDbContextExecutor.js","sourceRoot":"","sources":["../../../../sd-orm-common/src/IDbContextExecutor.ts"],"names":[],"mappings":""}

package/dist/sd-orm-common/src/IDbContextExecutor.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IDbContextExecutor.js.map

package/dist/sd-orm-common/src/IDbMigration.d.ts

@@ -0,0 +1,4 @@
+import { DbContext } from "./DbContext";
+export interface IDbMigration {
+    up(db: DbContext): Promise<void>;
+}

package/dist/sd-orm-common/src/IDbMigration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IDbMigration.js","sourceRoot":"","sources":["../../../../sd-orm-common/src/IDbMigration.ts"],"names":[],"mappings":""}