@simplysm/orm-common 13.0.100 → 14.0.1

package/dist/create-db-context.d.ts

@@ -1,18 +1,18 @@
 import type { DbContextDef, DbContextInstance } from "./types/db-context-def";
 import type { DbContextExecutor } from "./types/db";
 /**
- * DbContext instance factory
+ * DbContext 인스턴스 팩토리
  *
- * Takes DbContextDef (definition) and DbContextExecutor (executor) and creates
- * a complete DbContext instance including queryable accessors, DDL methods,
- * and connection/transaction management
+ * DbContextDef (정의)와 DbContextExecutor (실행기)를 받아
+ * queryable 접근자, DDL 메서드, 연결/트랜잭션 관리를 포함한
+ * 완전한 DbContext 인스턴스를 생성한다
  *
- * @param def - Definition object created by defineDbContext()
- * @param executor - Query executor (NodeDbContextExecutor, ServiceDbContextExecutor, etc.)
- * @param opt - Database options
- * @param opt.database - Database name
- * @param opt.schema - Schema name (MSSQL: dbo, PostgreSQL: public)
- * @returns A complete DbContext instance
+ * @param def - defineDbContext()로 생성된 정의 객체
+ * @param executor - 쿼리 실행기 (NodeDbContextExecutor, ServiceDbContextExecutor 등)
+ * @param opt - 데이터베이스 옵션
+ * @param opt.database - 데이터베이스 이름
+ * @param opt.schema - schema 이름 (MSSQL: dbo, PostgreSQL: public)
+ * @returns 완전한 DbContext 인스턴스
  *
  * @example
  * ```typescript

package/dist/create-db-context.js

@@ -5,289 +5,325 @@ import { ViewBuilder } from "./schema/view-builder.js";
 import { queryable } from "./exec/queryable.js";
 import { executable } from "./exec/executable.js";
 import { obj } from "@simplysm/core-common";
+// DDL import
 import * as tableDdl from "./ddl/table-ddl.js";
 import * as columnDdl from "./ddl/column-ddl.js";
 import * as relationDdl from "./ddl/relation-ddl.js";
 import * as schemaDdl from "./ddl/schema-ddl.js";
-import {
-  initialize as initializeImpl,
-  validateRelations as validateRelationsImpl
-} from "./ddl/initialize.js";
-function createDbContext(def, executor, opt) {
-  let aliasCounter = 0;
-  let status = "ready";
-  let relationsValidated = false;
-  const base = {
-    get status() {
-      return status;
-    },
-    set status(v) {
-      status = v;
-    },
-    get database() {
-      return opt.database;
-    },
-    get schema() {
-      return opt.schema;
-    },
-    getNextAlias() {
-      return `T${++aliasCounter}`;
-    },
-    resetAliasCounter() {
-      aliasCounter = 0;
-    },
-    executeDefs(defs, resultMetas) {
-      if (status === "transact" && defs.some((d) => DDL_TYPES.includes(d.type))) {
-        throw new Error("Cannot execute DDL while in TRANSACTION state.");
-      }
-      return executor.executeDefs(defs, resultMetas);
-    },
-    getQueryDefObjectName(tableOrView) {
-      return obj.clearUndefined({
-        database: tableOrView.meta.database ?? opt.database,
-        schema: tableOrView.meta.schema ?? opt.schema,
-        name: tableOrView.meta.name
-      });
-    },
-    async switchFk(table, enabled) {
-      await base.executeDefs([schemaDdl.getSwitchFkQueryDef(table, enabled)]);
-    }
-  };
-  const db = {
-    // Spread base properties (getters/setters need special handling)
-    get status() {
-      return base.status;
-    },
-    set status(v) {
-      base.status = v;
-    },
-    get database() {
-      return base.database;
-    },
-    get schema() {
-      return base.schema;
-    },
-    getNextAlias: base.getNextAlias,
-    resetAliasCounter: base.resetAliasCounter,
-    executeDefs: base.executeDefs,
-    getQueryDefObjectName: base.getQueryDefObjectName,
-    //#region ========== Connection management ==========
-    /**
-     * Execute callback within a transaction (automatic commit/rollback)
-     *
-     * Connect -> Start transaction -> Execute callback -> Commit -> Close connection
-     * If error occurs, automatically rollback and close connection
-     */
-    async connect(fn, isolationLevel) {
-      if (!relationsValidated) {
-        validateRelationsImpl(def);
-        relationsValidated = true;
-      }
-      base.resetAliasCounter();
-      await executor.connect();
-      status = "connect";
-      await executor.beginTransaction(isolationLevel);
-      status = "transact";
-      let result;
-      try {
-        result = await fn();
-        await executor.commitTransaction();
-        status = "connect";
-      } catch (err) {
-        try {
-          await executor.rollbackTransaction();
-          status = "connect";
-        } catch (err1) {
-          if (err1 instanceof DbTransactionError) {
-            if (err1.code !== DbErrorCode.NO_ACTIVE_TRANSACTION) {
-              await executor.close();
-              status = "ready";
-              throw err1;
+import { initialize as initializeImpl, validateRelations as validateRelationsImpl, } from "./ddl/initialize.js";
+/**
+ * DbContext 인스턴스 팩토리
+ *
+ * DbContextDef (정의)와 DbContextExecutor (실행기)를 받아
+ * queryable 접근자, DDL 메서드, 연결/트랜잭션 관리를 포함한
+ * 완전한 DbContext 인스턴스를 생성한다
+ *
+ * @param def - defineDbContext()로 생성된 정의 객체
+ * @param executor - 쿼리 실행기 (NodeDbContextExecutor, ServiceDbContextExecutor 등)
+ * @param opt - 데이터베이스 옵션
+ * @param opt.database - 데이터베이스 이름
+ * @param opt.schema - schema 이름 (MSSQL: dbo, PostgreSQL: public)
+ * @returns 완전한 DbContext 인스턴스
+ *
+ * @example
+ * ```typescript
+ * const MyDb = defineDbContext({
+ *   tables: { user: User, post: Post },
+ * });
+ *
+ * const db = createDbContext(MyDb, executor, { database: "mydb" });
+ *
+ * await db.connect(async () => {
+ *   const users = await db.user().execute();
+ * });
+ * ```
+ */
+export function createDbContext(def, executor, opt) {
+    // ── 내부 상태 (클로저) ──
+    let aliasCounter = 0;
+    let status = "ready";
+    let relationsValidated = false;
+    // ── DbContextBase 구현 ──
+    const base = {
+        get status() {
+            return status;
+        },
+        set status(v) {
+            status = v;
+        },
+        get database() {
+            return opt.database;
+        },
+        get schema() {
+            return opt.schema;
+        },
+        getNextAlias() {
+            return `T${++aliasCounter}`;
+        },
+        resetAliasCounter() {
+            aliasCounter = 0;
+        },
+        executeDefs(defs, resultMetas) {
+            if (status === "transact" &&
+                defs.some((d) => DDL_TYPES.includes(d.type))) {
+                throw new Error("TRANSACTION 상태에서는 DDL을 실행할 수 없습니다.");
+            }
+            return executor.executeDefs(defs, resultMetas);
+        },
+        getQueryDefObjectName(tableOrView) {
+            return obj.clearUndefined({
+                database: tableOrView.meta.database ?? opt.database,
+                schema: tableOrView.meta.schema ?? opt.schema,
+                name: tableOrView.meta.name,
+            });
+        },
+        async switchFk(table, enabled) {
+            await base.executeDefs([schemaDdl.getSwitchFkQueryDef(table, enabled)]);
+        },
+    };
+    // ── 모든 요소를 하나의 객체로 합성 ──
+    const db = {
+        // base 속성 전개 (getter/setter는 별도 처리 필요)
+        get status() {
+            return base.status;
+        },
+        set status(v) {
+            base.status = v;
+        },
+        get database() {
+            return base.database;
+        },
+        get schema() {
+            return base.schema;
+        },
+        getNextAlias: base.getNextAlias,
+        resetAliasCounter: base.resetAliasCounter,
+        executeDefs: base.executeDefs,
+        getQueryDefObjectName: base.getQueryDefObjectName,
+        //#region ========== 연결 관리 ==========
+        /**
+         * 트랜잭션 내에서 콜백 실행 (자동 커밋/롤백)
+         *
+         * 연결 -> 트랜잭션 시작 -> 콜백 실행 -> 커밋 -> 연결 종료
+         * 오류 발생 시 자동으로 롤백 후 연결 종료
+         */
+        async connect(fn, isolationLevel) {
+            if (!relationsValidated) {
+                validateRelationsImpl(def);
+                relationsValidated = true;
+            }
+            base.resetAliasCounter();
+            await executor.connect();
+            status = "connect";
+            await executor.beginTransaction(isolationLevel);
+            status = "transact";
+            let result;
+            try {
+                result = await fn();
+                await executor.commitTransaction();
+                status = "connect";
+            }
+            catch (err) {
+                try {
+                    await executor.rollbackTransaction();
+                    status = "connect";
+                }
+                catch (err1) {
+                    if (err1 instanceof DbTransactionError) {
+                        if (err1.code !== DbErrorCode.NO_ACTIVE_TRANSACTION) {
+                            await executor.close();
+                            status = "ready";
+                            throw err1;
+                        }
+                    }
+                    else {
+                        await executor.close();
+                        status = "ready";
+                        throw err1;
+                    }
+                }
+                await executor.close();
+                status = "ready";
+                throw err;
             }
-          } else {
             await executor.close();
             status = "ready";
-            throw err1;
-          }
-        }
-        await executor.close();
-        status = "ready";
-        throw err;
-      }
-      await executor.close();
-      status = "ready";
-      return result;
-    },
-    /**
-     * Connect without transaction, execute callback, and auto-close
-     *
-     * Used for DDL operations or read operations that don't require transactions
-     */
-    async connectWithoutTransaction(callback) {
-      if (!relationsValidated) {
-        validateRelationsImpl(def);
-        relationsValidated = true;
-      }
-      base.resetAliasCounter();
-      await executor.connect();
-      status = "connect";
-      let result;
-      try {
-        result = await callback();
-      } catch (err) {
-        await executor.close();
-        status = "ready";
-        throw err;
-      }
-      await executor.close();
-      status = "ready";
-      return result;
-    },
-    /**
-     * Start transaction in already connected state (automatic commit/rollback)
-     *
-     * Used when transaction is needed partially within connectWithoutTransaction
-     */
-    async transaction(fn, isolationLevel) {
-      if (status === "transact") {
-        throw new Error("Already in TRANSACTION state.");
-      }
-      await executor.beginTransaction(isolationLevel);
-      status = "transact";
-      let result;
-      try {
-        result = await fn();
-        await executor.commitTransaction();
-        status = "connect";
-      } catch (err) {
-        try {
-          await executor.rollbackTransaction();
-          status = "connect";
-        } catch (err1) {
-          if (err1 instanceof DbTransactionError) {
-            if (err1.code !== DbErrorCode.NO_ACTIVE_TRANSACTION) {
-              throw err1;
+            return result;
+        },
+        /**
+         * 트랜잭션 없이 연결 후 콜백 실행, 자동 종료
+         *
+         * 트랜잭션이 필요 없는 DDL 작업이나 읽기 작업에 사용
+         */
+        async connectWithoutTransaction(callback) {
+            if (!relationsValidated) {
+                validateRelationsImpl(def);
+                relationsValidated = true;
             }
-          } else {
-            throw err1;
-          }
-          status = "connect";
-        }
-        throw err;
-      }
-      return result;
-    },
-    //#endregion
-    //#region ========== DDL execution methods ==========
-    async createTable(table) {
-      await base.executeDefs([tableDdl.getCreateTableQueryDef(base, table)]);
-    },
-    async dropTable(table) {
-      await base.executeDefs([tableDdl.getDropTableQueryDef(table)]);
-    },
-    async renameTable(table, newName) {
-      await base.executeDefs([tableDdl.getRenameTableQueryDef(table, newName)]);
-    },
-    async createView(view) {
-      await base.executeDefs([tableDdl.getCreateViewQueryDef(db, view)]);
-    },
-    async dropView(view) {
-      await base.executeDefs([tableDdl.getDropViewQueryDef(view)]);
-    },
-    async createProc(procedure) {
-      await base.executeDefs([tableDdl.getCreateProcQueryDef(base, procedure)]);
-    },
-    async dropProc(procedure) {
-      await base.executeDefs([tableDdl.getDropProcQueryDef(procedure)]);
-    },
-    async addColumn(table, columnName, column) {
-      await base.executeDefs([columnDdl.getAddColumnQueryDef(table, columnName, column)]);
-    },
-    async dropColumn(table, column) {
-      await base.executeDefs([columnDdl.getDropColumnQueryDef(table, column)]);
-    },
-    async modifyColumn(table, columnName, column) {
-      await base.executeDefs([columnDdl.getModifyColumnQueryDef(table, columnName, column)]);
-    },
-    async renameColumn(table, column, newName) {
-      await base.executeDefs([columnDdl.getRenameColumnQueryDef(table, column, newName)]);
-    },
-    async addPrimaryKey(table, columns) {
-      await base.executeDefs([relationDdl.getAddPrimaryKeyQueryDef(table, columns)]);
-    },
-    async dropPrimaryKey(table) {
-      await base.executeDefs([relationDdl.getDropPrimaryKeyQueryDef(table)]);
-    },
-    async addForeignKey(table, relationName, relationDef) {
-      await base.executeDefs([
-        relationDdl.getAddForeignKeyQueryDef(base, table, relationName, relationDef)
-      ]);
-    },
-    async addIndex(table, indexBuilder) {
-      await base.executeDefs([relationDdl.getAddIndexQueryDef(table, indexBuilder)]);
-    },
-    async dropForeignKey(table, relationName) {
-      await base.executeDefs([relationDdl.getDropForeignKeyQueryDef(table, relationName)]);
-    },
-    async dropIndex(table, columns) {
-      await base.executeDefs([relationDdl.getDropIndexQueryDef(table, columns)]);
-    },
-    async clearSchema(params) {
-      await base.executeDefs([schemaDdl.getClearSchemaQueryDef(params)]);
-    },
-    async schemaExists(database, schema) {
-      const result = await base.executeDefs([schemaDdl.getSchemaExistsQueryDef(database, schema)]);
-      return result[0].length > 0;
-    },
-    async truncate(table) {
-      await base.executeDefs([schemaDdl.getTruncateQueryDef(table)]);
-    },
-    async switchFk(table, enabled) {
-      await base.executeDefs([schemaDdl.getSwitchFkQueryDef(table, enabled)]);
-    },
-    //#endregion
-    //#region ========== DDL QueryDef generators ==========
-    getCreateTableQueryDef: (table) => tableDdl.getCreateTableQueryDef(base, table),
-    getCreateViewQueryDef: (view) => tableDdl.getCreateViewQueryDef(db, view),
-    getCreateProcQueryDef: (procedure) => tableDdl.getCreateProcQueryDef(base, procedure),
-    getCreateObjectQueryDef: (builder) => tableDdl.getCreateObjectQueryDef(db, builder),
-    getDropTableQueryDef: tableDdl.getDropTableQueryDef,
-    getRenameTableQueryDef: tableDdl.getRenameTableQueryDef,
-    getDropViewQueryDef: tableDdl.getDropViewQueryDef,
-    getDropProcQueryDef: tableDdl.getDropProcQueryDef,
-    getAddColumnQueryDef: columnDdl.getAddColumnQueryDef,
-    getDropColumnQueryDef: columnDdl.getDropColumnQueryDef,
-    getModifyColumnQueryDef: columnDdl.getModifyColumnQueryDef,
-    getRenameColumnQueryDef: columnDdl.getRenameColumnQueryDef,
-    getAddPrimaryKeyQueryDef: relationDdl.getAddPrimaryKeyQueryDef,
-    getDropPrimaryKeyQueryDef: relationDdl.getDropPrimaryKeyQueryDef,
-    getAddForeignKeyQueryDef: (table, relationName, relationDef) => relationDdl.getAddForeignKeyQueryDef(base, table, relationName, relationDef),
-    getAddIndexQueryDef: relationDdl.getAddIndexQueryDef,
-    getDropForeignKeyQueryDef: relationDdl.getDropForeignKeyQueryDef,
-    getDropIndexQueryDef: relationDdl.getDropIndexQueryDef,
-    getClearSchemaQueryDef: schemaDdl.getClearSchemaQueryDef,
-    getSchemaExistsQueryDef: schemaDdl.getSchemaExistsQueryDef,
-    getTruncateQueryDef: schemaDdl.getTruncateQueryDef,
-    getSwitchFkQueryDef: schemaDdl.getSwitchFkQueryDef,
-    //#endregion
-    //#region ========== Initialize ==========
-    async initialize(options) {
-      await initializeImpl(db, def, options);
+            base.resetAliasCounter();
+            await executor.connect();
+            status = "connect";
+            let result;
+            try {
+                result = await callback();
+            }
+            catch (err) {
+                await executor.close();
+                status = "ready";
+                throw err;
+            }
+            await executor.close();
+            status = "ready";
+            return result;
+        },
+        /**
+         * 이미 연결된 상태에서 트랜잭션 시작 (자동 커밋/롤백)
+         *
+         * connectWithoutTransaction 내에서 부분적으로 트랜잭션이 필요할 때 사용
+         */
+        async transaction(fn, isolationLevel) {
+            if (status === "transact") {
+                throw new Error("이미 TRANSACTION 상태입니다.");
+            }
+            await executor.beginTransaction(isolationLevel);
+            status = "transact";
+            let result;
+            try {
+                result = await fn();
+                await executor.commitTransaction();
+                status = "connect";
+            }
+            catch (err) {
+                try {
+                    await executor.rollbackTransaction();
+                    status = "connect";
+                }
+                catch (err1) {
+                    if (err1 instanceof DbTransactionError) {
+                        if (err1.code !== DbErrorCode.NO_ACTIVE_TRANSACTION) {
+                            throw err1;
+                        }
+                    }
+                    else {
+                        throw err1;
+                    }
+                    // NO_ACTIVE_TRANSACTION 오류이면 무시하고 원래 오류를 던짐
+                    status = "connect";
+                }
+                throw err;
+            }
+            return result;
+        },
+        //#endregion
+        //#region ========== DDL 실행 메서드 ==========
+        async createTable(table) {
+            await base.executeDefs([tableDdl.getCreateTableQueryDef(base, table)]);
+        },
+        async dropTable(table) {
+            await base.executeDefs([tableDdl.getDropTableQueryDef(table)]);
+        },
+        async renameTable(table, newName) {
+            await base.executeDefs([tableDdl.getRenameTableQueryDef(table, newName)]);
+        },
+        async createView(view) {
+            await base.executeDefs([tableDdl.getCreateViewQueryDef(db, view)]);
+        },
+        async dropView(view) {
+            await base.executeDefs([tableDdl.getDropViewQueryDef(view)]);
+        },
+        async createProc(procedure) {
+            await base.executeDefs([tableDdl.getCreateProcQueryDef(base, procedure)]);
+        },
+        async dropProc(procedure) {
+            await base.executeDefs([tableDdl.getDropProcQueryDef(procedure)]);
+        },
+        async addColumn(table, columnName, column) {
+            await base.executeDefs([columnDdl.getAddColumnQueryDef(table, columnName, column)]);
+        },
+        async dropColumn(table, column) {
+            await base.executeDefs([columnDdl.getDropColumnQueryDef(table, column)]);
+        },
+        async modifyColumn(table, columnName, column) {
+            await base.executeDefs([columnDdl.getModifyColumnQueryDef(table, columnName, column)]);
+        },
+        async renameColumn(table, column, newName) {
+            await base.executeDefs([columnDdl.getRenameColumnQueryDef(table, column, newName)]);
+        },
+        async addPrimaryKey(table, columns) {
+            await base.executeDefs([relationDdl.getAddPrimaryKeyQueryDef(table, columns)]);
+        },
+        async dropPrimaryKey(table) {
+            await base.executeDefs([relationDdl.getDropPrimaryKeyQueryDef(table)]);
+        },
+        async addForeignKey(table, relationName, relationDef) {
+            await base.executeDefs([
+                relationDdl.getAddForeignKeyQueryDef(base, table, relationName, relationDef),
+            ]);
+        },
+        async addIndex(table, indexBuilder) {
+            await base.executeDefs([relationDdl.getAddIndexQueryDef(table, indexBuilder)]);
+        },
+        async dropForeignKey(table, relationName) {
+            await base.executeDefs([relationDdl.getDropForeignKeyQueryDef(table, relationName)]);
+        },
+        async dropIndex(table, columns) {
+            await base.executeDefs([relationDdl.getDropIndexQueryDef(table, columns)]);
+        },
+        async clearSchema(params) {
+            await base.executeDefs([schemaDdl.getClearSchemaQueryDef(params)]);
+        },
+        async schemaExists(database, schema) {
+            const result = await base.executeDefs([schemaDdl.getSchemaExistsQueryDef(database, schema)]);
+            return result[0].length > 0;
+        },
+        async truncate(table) {
+            await base.executeDefs([schemaDdl.getTruncateQueryDef(table)]);
+        },
+        async switchFk(table, enabled) {
+            await base.executeDefs([schemaDdl.getSwitchFkQueryDef(table, enabled)]);
+        },
+        //#endregion
+        //#region ========== DDL QueryDef 생성기 ==========
+        getCreateTableQueryDef: (table) => tableDdl.getCreateTableQueryDef(base, table),
+        getCreateViewQueryDef: (view) => tableDdl.getCreateViewQueryDef(db, view),
+        getCreateProcQueryDef: (procedure) => tableDdl.getCreateProcQueryDef(base, procedure),
+        getCreateObjectQueryDef: (builder) => tableDdl.getCreateObjectQueryDef(db, builder),
+        getDropTableQueryDef: tableDdl.getDropTableQueryDef,
+        getRenameTableQueryDef: tableDdl.getRenameTableQueryDef,
+        getDropViewQueryDef: tableDdl.getDropViewQueryDef,
+        getDropProcQueryDef: tableDdl.getDropProcQueryDef,
+        getAddColumnQueryDef: columnDdl.getAddColumnQueryDef,
+        getDropColumnQueryDef: columnDdl.getDropColumnQueryDef,
+        getModifyColumnQueryDef: columnDdl.getModifyColumnQueryDef,
+        getRenameColumnQueryDef: columnDdl.getRenameColumnQueryDef,
+        getAddPrimaryKeyQueryDef: relationDdl.getAddPrimaryKeyQueryDef,
+        getDropPrimaryKeyQueryDef: relationDdl.getDropPrimaryKeyQueryDef,
+        getAddForeignKeyQueryDef: (table, relationName, relationDef) => relationDdl.getAddForeignKeyQueryDef(base, table, relationName, relationDef),
+        getAddIndexQueryDef: relationDdl.getAddIndexQueryDef,
+        getDropForeignKeyQueryDef: relationDdl.getDropForeignKeyQueryDef,
+        getDropIndexQueryDef: relationDdl.getDropIndexQueryDef,
+        getClearSchemaQueryDef: schemaDdl.getClearSchemaQueryDef,
+        getSchemaExistsQueryDef: schemaDdl.getSchemaExistsQueryDef,
+        getTruncateQueryDef: schemaDdl.getTruncateQueryDef,
+        getSwitchFkQueryDef: schemaDdl.getSwitchFkQueryDef,
+        //#endregion
+        //#region ========== 초기화 ==========
+        async initialize(options) {
+            await initializeImpl(db, def, options);
+        },
+        //#endregion
+    };
+    // ── Queryable 접근자 추가 ──
+    for (const [key, tableOrView] of Object.entries(def.meta.tables)) {
+        db[key] = queryable(db, tableOrView);
+    }
+    for (const [key, view] of Object.entries(def.meta.views)) {
+        db[key] = queryable(db, view);
+    }
+    // ── Executable 접근자 추가 ──
+    for (const [key, proc] of Object.entries(def.meta.procedures)) {
+        db[key] = executable(base, proc);
     }
-    //#endregion
-  };
-  for (const [key, tableOrView] of Object.entries(def.meta.tables)) {
-    db[key] = queryable(db, tableOrView);
-  }
-  for (const [key, view] of Object.entries(def.meta.views)) {
-    db[key] = queryable(db, view);
-  }
-  for (const [key, proc] of Object.entries(def.meta.procedures)) {
-    db[key] = executable(base, proc);
-  }
-  return db;
+    return db;
 }
-export {
-  createDbContext
-};
-//# sourceMappingURL=create-db-context.js.map
+//# sourceMappingURL=create-db-context.js.map