@simplysm/orm-common 14.0.16 → 14.0.17

package/src/db-context.ts

@@ -0,0 +1,455 @@
+import type { DbContextBase, DbContextStatus } from "./types/db-context-def";
+import type { DataRecord, DbContextExecutor, IsolationLevel, Migration, ResultMeta } from "./types/db";
+import type { QueryDef, QueryDefObjectName } from "./types/query-def";
+import { DDL_TYPES } from "./types/query-def";
+
+const DDL_TYPE_SET: ReadonlySet<string> = new Set(DDL_TYPES);
+import { DbErrorCode, DbTransactionError } from "./errors/db-transaction-error";
+import { TableBuilder } from "./schema/table-builder";
+import { ViewBuilder } from "./schema/view-builder";
+import type { ProcedureBuilder } from "./schema/procedure-builder";
+import { queryable as createQueryable } from "./exec/queryable";
+import type { Queryable } from "./exec/queryable";
+import { executable as createExecutable } from "./exec/executable";
+import type { Executable } from "./exec/executable";
+
+// DDL import
+import * as tableDdl from "./ddl/table-ddl";
+import { getQueryDefObjectName as getQueryDefObjectNameImpl } from "./ddl/table-ddl";
+import * as columnDdl from "./ddl/column-ddl";
+import * as relationDdl from "./ddl/relation-ddl";
+import * as schemaDdl from "./ddl/schema-ddl";
+import {
+  initialize as initializeImpl,
+  validateRelations as validateRelationsImpl,
+} from "./ddl/initialize";
+
+import type { ColumnBuilder } from "./schema/factory/column-builder";
+import type { ForeignKeyBuilder } from "./schema/factory/relation-builder";
+import type { IndexBuilder } from "./schema/factory/index-builder";
+import { _Migration } from "./models/system-migration";
+
+export const SD_BUILDER = Symbol("sdBuilder");
+
+/**
+ * DbContext base class
+ *
+ * 테이블/뷰/프로시저를 class 프로퍼티로 등록하고,
+ * 연결/트랜잭션/DDL/초기화를 제공한다.
+ *
+ * defineDbContext/createDbContext의 class 기반 대체.
+ * 각 프로퍼티가 독립 직렬화되어 40+ 테이블에서도 TS7056이 발생하지 않는다.
+ *
+ * @example
+ * ```typescript
+ * class MainDb extends DbContext {
+ *   user = this.queryable(User);
+ *   post = this.queryable(Post);
+ *   activeUsers = this.queryable(ActiveUsers);
+ *   getUserById = this.executable(GetUserById);
+ *
+ *   migrations = [{ name: "001", up: async (db) => { ... } }];
+ * }
+ *
+ * const db = new MainDb(executor, { database: "mydb" });
+ * await db.connect(async () => {
+ *   const users = await db.user().execute();
+ * });
+ * ```
+ */
+export abstract class DbContext implements DbContextBase {
+  // ── 상태 ──
+  status: DbContextStatus = "ready";
+  private _aliasCounter = 0;
+  private _relationsValidated = false;
+
+  // ── 시스템 테이블 ──
+  _migration = this.queryable(_Migration);
+
+  constructor(
+    private readonly _executor: DbContextExecutor,
+    private readonly _opt: { database: string; schema?: string },
+  ) {}
+
+  // ── DbContextBase 구현 ──
+
+  get database(): string | undefined {
+    return this._opt.database;
+  }
+
+  get schema(): string | undefined {
+    return this._opt.schema;
+  }
+
+  getNextAlias(): string {
+    return `T${++this._aliasCounter}`;
+  }
+
+  resetAliasCounter(): void {
+    this._aliasCounter = 0;
+  }
+
+  executeDefs<T = DataRecord>(
+    defs: QueryDef[],
+    resultMetas?: (ResultMeta | undefined)[],
+  ): Promise<T[][]> {
+    if (this.status === "transact" && defs.some((d) => DDL_TYPE_SET.has(d.type))) {
+      throw new Error("TRANSACTION 상태에서는 DDL을 실행할 수 없습니다.");
+    }
+    return this._executor.executeDefs(defs, resultMetas);
+  }
+
+  getQueryDefObjectName(
+    tableOrView: TableBuilder<any, any> | ViewBuilder<any, any, any>,
+  ): QueryDefObjectName {
+    return getQueryDefObjectNameImpl(this, tableOrView);
+  }
+
+  async switchFk(table: QueryDefObjectName, enabled: boolean): Promise<void> {
+    await this.executeDefs([schemaDdl.getSwitchFkQueryDef(table, enabled)]);
+  }
+
+  // ── 등록 메서드 ──
+
+  protected queryable<T extends TableBuilder<any, any> | ViewBuilder<any, any, any>>(
+    builder: T,
+  ): () => Queryable<T["$inferSelect"], T extends TableBuilder<any, any> ? T : never> {
+    const fn = createQueryable(this, builder);
+    Object.defineProperty(fn, SD_BUILDER, { value: builder });
+    return fn;
+  }
+
+  protected executable<T extends ProcedureBuilder<any, any>>(
+    builder: T,
+  ): () => Executable<T["$params"], T["$returns"]> {
+    const fn = createExecutable(this, builder);
+    Object.defineProperty(fn, SD_BUILDER, { value: builder });
+    return fn;
+  }
+
+  // ── 연결 관리 ──
+
+  async connect<TResult>(
+    fn: () => Promise<TResult>,
+    isolationLevel?: IsolationLevel,
+  ): Promise<TResult> {
+    if (this.status !== "ready") {
+      throw new Error(
+        `이미 ${this.status === "connect" ? "CONNECT" : "TRANSACTION"} 상태입니다.`,
+      );
+    }
+    if (!this._relationsValidated) {
+      validateRelationsImpl(this);
+      this._relationsValidated = true;
+    }
+    this.resetAliasCounter();
+
+    await this._executor.connect();
+    this.status = "connect";
+
+    try {
+      await this._executor.beginTransaction(isolationLevel);
+      this.status = "transact";
+
+      let result: TResult;
+      try {
+        result = await fn();
+
+        await this._executor.commitTransaction();
+        this.status = "connect";
+      } catch (err) {
+        try {
+          await this._executor.rollbackTransaction();
+        } catch (err1) {
+          if (
+            !(err1 instanceof DbTransactionError) ||
+            err1.code !== DbErrorCode.NO_ACTIVE_TRANSACTION
+          ) {
+            (err as Error).cause = err1;
+          }
+        }
+        this.status = "connect";
+        throw err;
+      }
+
+      return result;
+    } finally {
+      try {
+        await this._executor.close();
+      } finally {
+        this.status = "ready";
+      }
+    }
+  }
+
+  async connectWithoutTransaction<TResult>(callback: () => Promise<TResult>): Promise<TResult> {
+    if (this.status !== "ready") {
+      throw new Error(
+        `이미 ${this.status === "connect" ? "CONNECT" : "TRANSACTION"} 상태입니다.`,
+      );
+    }
+    if (!this._relationsValidated) {
+      validateRelationsImpl(this);
+      this._relationsValidated = true;
+    }
+    this.resetAliasCounter();
+
+    await this._executor.connect();
+    this.status = "connect";
+
+    try {
+      return await callback();
+    } finally {
+      try {
+        await this._executor.close();
+      } finally {
+        this.status = "ready";
+      }
+    }
+  }
+
+  async transaction<TResult>(
+    fn: () => Promise<TResult>,
+    isolationLevel?: IsolationLevel,
+  ): Promise<TResult> {
+    if (this.status === "transact") {
+      throw new Error("이미 TRANSACTION 상태입니다.");
+    }
+
+    await this._executor.beginTransaction(isolationLevel);
+    this.status = "transact";
+
+    let result: TResult;
+    try {
+      result = await fn();
+
+      await this._executor.commitTransaction();
+      this.status = "connect";
+    } catch (err) {
+      try {
+        await this._executor.rollbackTransaction();
+      } catch (err1) {
+        if (
+          !(err1 instanceof DbTransactionError) ||
+          err1.code !== DbErrorCode.NO_ACTIVE_TRANSACTION
+        ) {
+          (err as Error).cause = err1;
+        }
+      }
+      this.status = "connect";
+      throw err;
+    }
+
+    return result;
+  }
+
+  // ── DDL 실행 메서드 ──
+
+  async createTable(table: TableBuilder<any, any>): Promise<void> {
+    await this.executeDefs([tableDdl.getCreateTableQueryDef(this, table)]);
+  }
+
+  async dropTable(table: QueryDefObjectName): Promise<void> {
+    await this.executeDefs([tableDdl.getDropTableQueryDef(table)]);
+  }
+
+  async renameTable(table: QueryDefObjectName, newName: string): Promise<void> {
+    await this.executeDefs([tableDdl.getRenameTableQueryDef(table, newName)]);
+  }
+
+  async createView(view: ViewBuilder<any, any, any>): Promise<void> {
+    await this.executeDefs([tableDdl.getCreateViewQueryDef(this as any, view)]);
+  }
+
+  async dropView(view: QueryDefObjectName): Promise<void> {
+    await this.executeDefs([tableDdl.getDropViewQueryDef(view)]);
+  }
+
+  async createProc(procedure: ProcedureBuilder<any, any>): Promise<void> {
+    await this.executeDefs([tableDdl.getCreateProcQueryDef(this, procedure)]);
+  }
+
+  async dropProc(procedure: QueryDefObjectName): Promise<void> {
+    await this.executeDefs([tableDdl.getDropProcQueryDef(procedure)]);
+  }
+
+  async addColumn(
+    table: QueryDefObjectName,
+    columnName: string,
+    column: ColumnBuilder<any, any>,
+  ): Promise<void> {
+    await this.executeDefs([columnDdl.getAddColumnQueryDef(table, columnName, column)]);
+  }
+
+  async dropColumn(table: QueryDefObjectName, column: string): Promise<void> {
+    await this.executeDefs([columnDdl.getDropColumnQueryDef(table, column)]);
+  }
+
+  async modifyColumn(
+    table: QueryDefObjectName,
+    columnName: string,
+    column: ColumnBuilder<any, any>,
+  ): Promise<void> {
+    await this.executeDefs([columnDdl.getModifyColumnQueryDef(table, columnName, column)]);
+  }
+
+  async renameColumn(table: QueryDefObjectName, column: string, newName: string): Promise<void> {
+    await this.executeDefs([columnDdl.getRenameColumnQueryDef(table, column, newName)]);
+  }
+
+  async addPrimaryKey(table: QueryDefObjectName, columns: string[]): Promise<void> {
+    await this.executeDefs([relationDdl.getAddPrimaryKeyQueryDef(table, columns)]);
+  }
+
+  async dropPrimaryKey(table: QueryDefObjectName): Promise<void> {
+    await this.executeDefs([relationDdl.getDropPrimaryKeyQueryDef(table)]);
+  }
+
+  async addForeignKey(
+    table: QueryDefObjectName,
+    relationName: string,
+    relationDef: ForeignKeyBuilder<any, any>,
+  ): Promise<void> {
+    await this.executeDefs([
+      relationDdl.getAddForeignKeyQueryDef(this, table, relationName, relationDef),
+    ]);
+  }
+
+  async addIndex(table: QueryDefObjectName, indexBuilder: IndexBuilder<string[]>): Promise<void> {
+    await this.executeDefs([relationDdl.getAddIndexQueryDef(table, indexBuilder)]);
+  }
+
+  async dropForeignKey(table: QueryDefObjectName, relationName: string): Promise<void> {
+    await this.executeDefs([relationDdl.getDropForeignKeyQueryDef(table, relationName)]);
+  }
+
+  async dropIndex(table: QueryDefObjectName, columns: string[]): Promise<void> {
+    await this.executeDefs([relationDdl.getDropIndexQueryDef(table, columns)]);
+  }
+
+  async clearSchema(params: { database: string; schema?: string }): Promise<void> {
+    await this.executeDefs([schemaDdl.getClearSchemaQueryDef(params)]);
+  }
+
+  async schemaExists(database: string, schema?: string): Promise<boolean> {
+    const result = await this.executeDefs([schemaDdl.getSchemaExistsQueryDef(database, schema)]);
+    return result[0].length > 0;
+  }
+
+  async truncate(table: QueryDefObjectName): Promise<void> {
+    await this.executeDefs([schemaDdl.getTruncateQueryDef(table)]);
+  }
+
+  // ── DDL QueryDef 생성기 ──
+
+  getCreateTableQueryDef(table: TableBuilder<any, any>): QueryDef {
+    return tableDdl.getCreateTableQueryDef(this, table);
+  }
+
+  getCreateViewQueryDef(view: ViewBuilder<any, any, any>): QueryDef {
+    return tableDdl.getCreateViewQueryDef(this as any, view);
+  }
+
+  getCreateProcQueryDef(procedure: ProcedureBuilder<any, any>): QueryDef {
+    return tableDdl.getCreateProcQueryDef(this, procedure);
+  }
+
+  getCreateObjectQueryDef(
+    builder: TableBuilder<any, any> | ViewBuilder<any, any, any> | ProcedureBuilder<any, any>,
+  ): QueryDef {
+    return tableDdl.getCreateObjectQueryDef(this as any, builder);
+  }
+
+  getDropTableQueryDef(table: QueryDefObjectName): QueryDef {
+    return tableDdl.getDropTableQueryDef(table);
+  }
+
+  getRenameTableQueryDef(table: QueryDefObjectName, newName: string): QueryDef {
+    return tableDdl.getRenameTableQueryDef(table, newName);
+  }
+
+  getDropViewQueryDef(view: QueryDefObjectName): QueryDef {
+    return tableDdl.getDropViewQueryDef(view);
+  }
+
+  getDropProcQueryDef(procedure: QueryDefObjectName): QueryDef {
+    return tableDdl.getDropProcQueryDef(procedure);
+  }
+
+  getAddColumnQueryDef(
+    table: QueryDefObjectName,
+    columnName: string,
+    column: ColumnBuilder<any, any>,
+  ): QueryDef {
+    return columnDdl.getAddColumnQueryDef(table, columnName, column);
+  }
+
+  getDropColumnQueryDef(table: QueryDefObjectName, column: string): QueryDef {
+    return columnDdl.getDropColumnQueryDef(table, column);
+  }
+
+  getModifyColumnQueryDef(
+    table: QueryDefObjectName,
+    columnName: string,
+    column: ColumnBuilder<any, any>,
+  ): QueryDef {
+    return columnDdl.getModifyColumnQueryDef(table, columnName, column);
+  }
+
+  getRenameColumnQueryDef(table: QueryDefObjectName, column: string, newName: string): QueryDef {
+    return columnDdl.getRenameColumnQueryDef(table, column, newName);
+  }
+
+  getAddPrimaryKeyQueryDef(table: QueryDefObjectName, columns: string[]): QueryDef {
+    return relationDdl.getAddPrimaryKeyQueryDef(table, columns);
+  }
+
+  getDropPrimaryKeyQueryDef(table: QueryDefObjectName): QueryDef {
+    return relationDdl.getDropPrimaryKeyQueryDef(table);
+  }
+
+  getAddForeignKeyQueryDef(
+    table: QueryDefObjectName,
+    relationName: string,
+    relationDef: ForeignKeyBuilder<any, any>,
+  ): QueryDef {
+    return relationDdl.getAddForeignKeyQueryDef(this, table, relationName, relationDef);
+  }
+
+  getAddIndexQueryDef(table: QueryDefObjectName, indexBuilder: IndexBuilder<string[]>): QueryDef {
+    return relationDdl.getAddIndexQueryDef(table, indexBuilder);
+  }
+
+  getDropForeignKeyQueryDef(table: QueryDefObjectName, relationName: string): QueryDef {
+    return relationDdl.getDropForeignKeyQueryDef(table, relationName);
+  }
+
+  getDropIndexQueryDef(table: QueryDefObjectName, columns: string[]): QueryDef {
+    return relationDdl.getDropIndexQueryDef(table, columns);
+  }
+
+  getClearSchemaQueryDef(params: { database: string; schema?: string }): QueryDef {
+    return schemaDdl.getClearSchemaQueryDef(params);
+  }
+
+  getSchemaExistsQueryDef(database: string, schema?: string): QueryDef {
+    return schemaDdl.getSchemaExistsQueryDef(database, schema);
+  }
+
+  getTruncateQueryDef(table: QueryDefObjectName): QueryDef {
+    return schemaDdl.getTruncateQueryDef(table);
+  }
+
+  getSwitchFkQueryDef(table: QueryDefObjectName, enabled: boolean): QueryDef {
+    return schemaDdl.getSwitchFkQueryDef(table, enabled);
+  }
+
+  // ── 초기화 ──
+
+  async initialize(options?: { dbs?: string[]; force?: boolean }): Promise<void> {
+    await initializeImpl(this, options);
+  }
+
+  /** 마이그레이션 정의 — 서브클래스에서 오버라이드 */
+  migrations: Migration[] = [];
+}

package/src/ddl/initialize.ts

@@ -1,6 +1,7 @@
-import type { DbContextBase, DbContextDef, DbContextDdlMethods } from "../types/db-context-def";
+import type { DbContextBase, DbContextDdlMethods } from "../types/db-context-def";
 import type { Queryable } from "../exec/queryable";
 import type { QueryDef } from "../types/query-def";
+import type { Migration } from "../types/db";
 import { TableBuilder } from "../schema/table-builder";
 import { ViewBuilder } from "../schema/view-builder";
 import { ProcedureBuilder } from "../schema/procedure-builder";
@@ -13,6 +14,7 @@ import {
 import { getCreateObjectQueryDef } from "./table-ddl";
 import { getAddForeignKeyQueryDef, getAddIndexQueryDef } from "./relation-ddl";
 import { getClearSchemaQueryDef, getSchemaExistsQueryDef } from "./schema-ddl";
+import { SD_BUILDER } from "../db-context";
 
 /**
  * Code First 데이터베이스 초기화
@@ -35,8 +37,11 @@ import { getClearSchemaQueryDef, getSchemaExistsQueryDef } from "./schema-ddl";
  *   - _Migration 테이블 있음: 미적용 migration만 실행
  */
 export async function initialize(
-  db: DbContextBase & DbContextDdlMethods & { _migration: () => Queryable<{ code: string }, any> },
-  def: DbContextDef<any, any, any>,
+  db: DbContextBase &
+    DbContextDdlMethods & {
+      _migration: () => Queryable<{ code: string }, any>;
+      migrations: Migration[];
+    },
   options?: { dbs?: string[]; force?: boolean },
 ): Promise<void> {
   const dbNames = options?.dbs ?? (db.database !== undefined ? [db.database] : []);
@@ -45,6 +50,8 @@ export async function initialize(
   }
 
   const force = options?.force ?? false;
+  const builders = collectBuilders(db);
+  const migrations = db.migrations;
 
   // 1. DB 존재 여부 확인
   for (const dbName of dbNames) {
@@ -62,14 +69,18 @@ export async function initialize(
       const clearDef = getClearSchemaQueryDef({ database: dbName, schema: db.schema });
       await db.executeDefs([clearDef]);
     }
-    await createAllObjects(db, def);
+
+    // 각 대상 DB에 객체 생성
+    for (const dbName of dbNames) {
+      await createAllObjects(db, builders, dbName);
+    }
 
     // 모든 migration을 "적용됨"으로 등록
-    if (def.meta.migrations.length > 0) {
-      await db._migration().insert(def.meta.migrations.map((m) => ({ code: m.name })));
+    if (migrations.length > 0) {
+      await db._migration().insert(migrations.map((m) => ({ code: m.name })));
     }
   } else {
-    // 3. Migration 기반 초기화
+    // 3. Migration 기반 초기화 — 각 대상 DB에 대해 수행
     let appliedMigrations: { code: string }[] | undefined;
     try {
       appliedMigrations = await db._migration().execute();
@@ -81,17 +92,19 @@ export async function initialize(
     }
 
     if (appliedMigrations == null) {
-      // 새 환경: 전체 생성
-      await createAllObjects(db, def);
+      // 새 환경: 각 대상 DB에 전체 생성
+      for (const dbName of dbNames) {
+        await createAllObjects(db, builders, dbName);
+      }
 
       // 모든 migration을 "적용됨"으로 등록
-      if (def.meta.migrations.length > 0) {
-        await db._migration().insert(def.meta.migrations.map((m) => ({ code: m.name })));
+      if (migrations.length > 0) {
+        await db._migration().insert(migrations.map((m) => ({ code: m.name })));
       }
     } else {
       // 기존 환경: 미적용 migration만 실행
       const appliedCodes = new Set(appliedMigrations.map((m) => m.code));
-      const pendingMigrations = def.meta.migrations.filter((m) => !appliedCodes.has(m.name));
+      const pendingMigrations = migrations.filter((m) => !appliedCodes.has(m.name));
 
       for (const migration of pendingMigrations) {
         await migration.up(db);
@@ -103,15 +116,26 @@ export async function initialize(
 
 /**
  * 모든 객체 생성 (table/view/procedure/FK/index)
+ *
+ * @param db - DbContext 인스턴스
+ * @param builders - 생성할 builder 목록
+ * @param targetDatabase - 대상 데이터베이스. builder에 database가 지정된 경우 해당 builder의 database가 targetDatabase와
+ *   일치할 때만 생성한다. 미지정 builder는 targetDatabase에 생성한다.
  */
 async function createAllObjects(
   db: DbContextBase,
-  def: DbContextDef<any, any, any>,
+  builders: (TableBuilder<any, any> | ViewBuilder<any, any, any> | ProcedureBuilder<any, any>)[],
+  targetDatabase: string,
 ): Promise<void> {
+  // targetDatabase에 해당하는 builder만 필터링
+  const targetBuilders = builders.filter((b) => {
+    const builderDb = b.meta.database;
+    return builderDb == null || builderDb === targetDatabase;
+  });
+
   // 1. Table/View/Procedure 생성
-  const builders = getBuilders(def);
   const createDefs: QueryDef[] = [];
-  for (const builder of builders) {
+  for (const builder of targetBuilders) {
     createDefs.push(getCreateObjectQueryDef(db, builder));
   }
   if (createDefs.length > 0) {
@@ -119,7 +143,7 @@ async function createAllObjects(
   }
 
   // 2. FK 생성 (TableBuilder만)
-  const tables = builders.filter((b) => b instanceof TableBuilder);
+  const tables = targetBuilders.filter((b) => b instanceof TableBuilder);
   const addFkDefs: QueryDef[] = [];
   for (const table of tables) {
     const relations = table.meta.relations;
@@ -153,10 +177,10 @@ async function createAllObjects(
 }
 
 /**
- * DbContext에서 모든 builder 수집 (Table/View/Procedure)
+ * DbContext 인스턴스에서 SD_BUILDER 태그가 붙은 builder를 수집
  */
-function getBuilders(
-  def: DbContextDef<any, any, any>,
+function collectBuilders(
+  dbContext: object,
 ): (TableBuilder<any, any> | ViewBuilder<any, any, any> | ProcedureBuilder<any, any>)[] {
   const builders: (
     | TableBuilder<any, any>
@@ -164,22 +188,10 @@ function getBuilders(
     | ProcedureBuilder<any, any>
   )[] = [];
 
-  // Tables
-  const tables: TableBuilder<any, any>[] = Object.values(def.meta.tables);
-  for (const table of tables) {
-    builders.push(table);
-  }
-
-  // Views
-  const views: ViewBuilder<any, any, any>[] = Object.values(def.meta.views);
-  for (const view of views) {
-    builders.push(view);
-  }
-
-  // Procedures
-  const procs: ProcedureBuilder<any, any>[] = Object.values(def.meta.procedures);
-  for (const proc of procs) {
-    builders.push(proc);
+  for (const value of Object.values(dbContext)) {
+    if (typeof value === "function" && SD_BUILDER in value) {
+      builders.push(value[SD_BUILDER as keyof typeof value] as TableBuilder<any, any>);
+    }
   }
 
   return builders;
@@ -189,8 +201,8 @@ function getBuilders(
  * ForeignKeyTarget/RelationKeyTarget 관계 검증
  * - targetTableFn()이 반환하는 테이블에 relationName과 일치하는 FK/RelationKey가 있는지 확인
  */
-export function validateRelations(def: DbContextDef<any, any, any>): void {
-  const builders = getBuilders(def);
+export function validateRelations(dbContext: object): void {
+  const builders = collectBuilders(dbContext);
   const tables = builders.filter((b) => b instanceof TableBuilder);
 
   for (const table of tables) {

package/src/exec/executable.ts

@@ -47,7 +47,7 @@ export class Executable<TParams extends ColumnBuilderRecord, TReturns extends Co
       params:
         params && meta.params
           ? Object.fromEntries(
-              Object.keys(params).map((key) => [
+              Object.keys(meta.params).map((key) => [
                 key,
                 params[key] instanceof ExprUnit
                   ? params[key].expr

package/src/exec/queryable.ts

@@ -1127,8 +1127,8 @@ export class Queryable<
    * ```
    */
   async exists(): Promise<boolean> {
-    const count = await this.count();
-    return count > 0;
+    const result = await this.top(1).execute();
+    return result.length > 0;
   }
 
   getSelectQueryDef(): SelectQueryDef {

package/src/exec/search-parser.ts

@@ -96,7 +96,8 @@ export function parseSearchQuery(searchText: string): ParsedSearchQuery {
     .replace(/\\%/g, ESC.PERCENT)
     .replace(/\\"/g, ESC.QUOTE)
     .replace(/\\\+/g, ESC.PLUS)
-    .replace(/\\-/g, ESC.MINUS);
+    .replace(/\\-/g, ESC.MINUS)
+    .replace(/\\(.)/g, "$1"); // 미정의 이스케이프: backslash 제거, 리터럴 문자 유지
 
   // 따옴표 구간 추출
   const quotedRegex = /([+-]?)"([^"]*)"/g;

package/src/expr/expr.ts

@@ -912,7 +912,7 @@ export const expr = {
    * @example
    * ```typescript
    * db.order().select((o) => ({
-   *   pages: expr.ceil(expr.divide(o.itemCount, 10)),
+   *   pages: expr.ceil(expr.multiply(o.itemCount, 0.1)),
    * }))
    * // SELECT CEILING(itemCount / 10) AS pages
    * // 25 / 10 = 2.5 → 3
@@ -934,7 +934,7 @@ export const expr = {
    * @example
    * ```typescript
    * db.user().select((u) => ({
-   *   ageGroup: expr.floor(expr.divide(u.age, 10)),
+   *   ageGroup: expr.floor(expr.multiply(u.age, 0.1)),
    * }))
    * // SELECT FLOOR(age / 10) AS ageGroup
    * // 25 / 10 = 2.5 → 2

package/src/index.ts

@@ -1,8 +1,7 @@
 //#region ========== Core ==========
 
-// 함수형 API (권장)
-export * from "./define-db-context";
-export * from "./create-db-context";
+// Class 기반 API
+export * from "./db-context";
 export * from "./types/db-context-def";
 export * from "./errors/db-transaction-error";