@simplysm/orm-common 13.0.16 → 13.0.18

package/src/expr/expr.ts

@@ -23,9 +23,9 @@ interface WinSpecInput {
 /**
  * Switch 표현식 빌더 인터페이스
  */
-export interface SwitchExprBuilder<T extends ColumnPrimitive> {
-  case(condition: WhereExprUnit, then: ExprInput<T>): SwitchExprBuilder<T>;
-  default(value: ExprInput<T>): ExprUnit<T>;
+export interface SwitchExprBuilder<TPrimitive extends ColumnPrimitive> {
+  case(condition: WhereExprUnit, then: ExprInput<TPrimitive>): SwitchExprBuilder<TPrimitive>;
+  default(value: ExprInput<TPrimitive>): ExprUnit<TPrimitive>;
 }
 
 /**
@@ -2015,23 +2015,27 @@ export const expr = {
 //#region ========== Internal Helpers ==========
 
 // 여러 값 중 첫 번째 non-null 반환 (COALESCE)
-function ifNull<T extends ColumnPrimitive>(
-  ...args: [ExprInput<T | undefined>, ...ExprInput<T | undefined>[], ExprInput<NonNullable<T>>]
-): ExprUnit<NonNullable<T>>;
-function ifNull<T extends ColumnPrimitive>(...args: ExprInput<T>[]): ExprUnit<T>;
-function ifNull<T extends ColumnPrimitive>(...args: ExprInput<T>[]): ExprUnit<T> {
+function ifNull<TPrimitive extends ColumnPrimitive>(
+  ...args: [
+    ExprInput<TPrimitive | undefined>,
+    ...ExprInput<TPrimitive | undefined>[],
+    ExprInput<NonNullable<TPrimitive>>,
+  ]
+): ExprUnit<NonNullable<TPrimitive>>;
+function ifNull<TPrimitive extends ColumnPrimitive>(...args: ExprInput<TPrimitive>[]): ExprUnit<TPrimitive>;
+function ifNull<TPrimitive extends ColumnPrimitive>(...args: ExprInput<TPrimitive>[]): ExprUnit<TPrimitive> {
   return new ExprUnit(findDataType(args), {
     type: "ifNull",
     args: args.map((a) => toExpr(a)),
   });
 }
 
-function createSwitchBuilder<T extends ColumnPrimitive>(): SwitchExprBuilder<T> {
+function createSwitchBuilder<TPrimitive extends ColumnPrimitive>(): SwitchExprBuilder<TPrimitive> {
   const cases: { when: WhereExpr; then: Expr }[] = [];
-  const thenValues: ExprInput<T>[] = []; // then 값들 저장
+  const thenValues: ExprInput<TPrimitive>[] = []; // then 값들 저장
 
   return {
-    case(condition: WhereExprUnit, then: ExprInput<T>): typeof this {
+    case(condition: WhereExprUnit, then: ExprInput<TPrimitive>): typeof this {
       cases.push({
         when: condition.expr,
         then: toExpr(then),
@@ -2039,10 +2043,10 @@ function createSwitchBuilder<T extends ColumnPrimitive>(): SwitchExprBuilder<T>
       thenValues.push(then);
       return this;
     },
-    default(value: ExprInput<T>): ExprUnit<T> {
+    default(value: ExprInput<TPrimitive>): ExprUnit<TPrimitive> {
       const allValues = [...thenValues, value];
       // 1. ExprUnit에서 dataType 찾기
-      const exprUnit = allValues.find((v): v is ExprUnit<T> => v instanceof ExprUnit);
+      const exprUnit = allValues.find((v): v is ExprUnit<TPrimitive> => v instanceof ExprUnit);
       if (exprUnit) {
         return new ExprUnit(exprUnit.dataType, {
           type: "switch",
@@ -2073,8 +2077,8 @@ export function toExpr(value: ExprInput<ColumnPrimitive>): Expr {
   return { type: "value", value };
 }
 
-function findDataType<T extends ColumnPrimitive>(args: ExprInput<T>[]): ColumnPrimitiveStr {
-  const exprUnit = args.find((a): a is ExprUnit<T> => a instanceof ExprUnit);
+function findDataType<TPrimitive extends ColumnPrimitive>(args: ExprInput<TPrimitive>[]): ColumnPrimitiveStr {
+  const exprUnit = args.find((a): a is ExprUnit<TPrimitive> => a instanceof ExprUnit);
   if (!exprUnit) {
     throw new Error("args중 적어도 하나는 ExprUnit이어야 합니다.");
   }

package/src/index.ts

@@ -1,246 +1,77 @@
-// ============================================
-// orm-common 패키지 진입점
-// ============================================
-
 //#region ========== Core ==========
 
 // Functional API (recommended)
-export { defineDbContext } from "./define-db-context";
-export { createDbContext } from "./create-db-context";
-export type {
-  DbContextBase,
-  DbContextDef,
-  DbContextInstance,
-  DbContextConnectionMethods,
-  DbContextDdlMethods,
-  DbContextStatus,
-} from "./types/db-context-def";
-
-export { DbTransactionError, DbErrorCode } from "./errors/db-transaction-error";
+export * from "./define-db-context";
+export * from "./create-db-context";
+export * from "./types/db-context-def";
+export * from "./errors/db-transaction-error";
 
 //#endregion
 
 //#region ========== Queryable / Executable ==========
 
-export { Queryable, queryable, getMatchedPrimaryKeys } from "./exec/queryable";
-export type { QueryableRecord, PathProxy } from "./exec/queryable";
-
-export { Executable, executable } from "./exec/executable";
-
-export { parseSearchQuery, type ParsedSearchQuery } from "./exec/search-parser";
+export * from "./exec/queryable";
+export * from "./exec/executable";
+export * from "./exec/search-parser";
 
 //#endregion
 
 //#region ========== Expression ==========
 
-export { expr, toExpr, type SwitchExprBuilder } from "./expr/expr";
-export { ExprUnit, WhereExprUnit, type ExprInput } from "./expr/expr-unit";
+export * from "./expr/expr";
+export * from "./expr/expr-unit";
 
 //#endregion
 
 //#region ========== Schema Builders ==========
 
-export { TableBuilder, Table } from "./schema/table-builder";
-export { ViewBuilder, View } from "./schema/view-builder";
-export { ProcedureBuilder, Procedure } from "./schema/procedure-builder";
-
-export {
-  ColumnBuilder,
-  createColumnFactory,
-  type ColumnBuilderRecord,
-  type InferColumns,
-  type InferInsertColumns,
-  type InferUpdateColumns,
-  type InferColumnExprs,
-  type DataToColumnBuilderRecord,
-} from "./schema/factory/column-builder";
-
-export { IndexBuilder, createIndexFactory } from "./schema/factory/index-builder";
-
-export {
-  ForeignKeyBuilder,
-  ForeignKeyTargetBuilder,
-  RelationKeyBuilder,
-  RelationKeyTargetBuilder,
-  createRelationFactory,
-  type RelationBuilderRecord,
-  type InferDeepRelations,
-} from "./schema/factory/relation-builder";
+// Table / View / Procedure
+export * from "./schema/table-builder";
+export * from "./schema/view-builder";
+export * from "./schema/procedure-builder";
+
+// Factory
+export * from "./schema/factory/column-builder";
+export * from "./schema/factory/index-builder";
+export * from "./schema/factory/relation-builder";
 
 //#endregion
 
 //#region ========== Models ==========
 
-export { SystemMigration } from "./models/system-migration";
+export * from "./models/system-migration";
 
 //#endregion
 
 //#region ========== Query Builder ==========
 
-export { createQueryBuilder } from "./query-builder/query-builder";
-export { QueryBuilderBase } from "./query-builder/base/query-builder-base";
-export { ExprRendererBase } from "./query-builder/base/expr-renderer-base";
-export { MysqlQueryBuilder } from "./query-builder/mysql/mysql-query-builder";
-export { MysqlExprRenderer } from "./query-builder/mysql/mysql-expr-renderer";
-export { MssqlQueryBuilder } from "./query-builder/mssql/mssql-query-builder";
-export { MssqlExprRenderer } from "./query-builder/mssql/mssql-expr-renderer";
-export { PostgresqlQueryBuilder } from "./query-builder/postgresql/postgresql-query-builder";
-export { PostgresqlExprRenderer } from "./query-builder/postgresql/postgresql-expr-renderer";
+export * from "./query-builder/query-builder";
+export * from "./query-builder/base/query-builder-base";
+export * from "./query-builder/base/expr-renderer-base";
+export * from "./query-builder/mysql/mysql-query-builder";
+export * from "./query-builder/mysql/mysql-expr-renderer";
+export * from "./query-builder/mssql/mssql-query-builder";
+export * from "./query-builder/mssql/mssql-expr-renderer";
+export * from "./query-builder/postgresql/postgresql-query-builder";
+export * from "./query-builder/postgresql/postgresql-expr-renderer";
 
 //#endregion
 
 //#region ========== Types ==========
 
 // Database types
-export type {
-  Dialect,
-  IsolationLevel,
-  DataRecord,
-  DbContextExecutor,
-  ResultMeta,
-  Migration,
-  QueryBuildResult,
-} from "./types/db";
-export { dialects } from "./types/db";
+export * from "./types/db";
 
 // Result parsing
-export { parseQueryResult } from "./utils/result-parser";
+export * from "./utils/result-parser";
 
 // Column types
-export type {
-  DataType,
-  ColumnPrimitiveMap,
-  ColumnPrimitiveStr,
-  ColumnPrimitive,
-  ColumnMeta,
-  InferColumnPrimitiveFromDataType,
-} from "./types/column";
-export { dataTypeStrToColumnPrimitiveStr, inferColumnPrimitiveStr } from "./types/column";
+export * from "./types/column";
 
 // Expression types
-export type {
-  Expr,
-  WhereExpr,
-  DateSeparator,
-  WinSpec,
-  // Value expressions
-  ExprColumn,
-  ExprValue,
-  ExprRaw,
-  // Comparison expressions
-  ExprEq,
-  ExprGt,
-  ExprLt,
-  ExprGte,
-  ExprLte,
-  ExprBetween,
-  ExprIsNull,
-  ExprLike,
-  ExprRegexp,
-  ExprIn,
-  ExprInQuery,
-  ExprExists,
-  // Logical expressions
-  ExprNot,
-  ExprAnd,
-  ExprOr,
-  // String expressions
-  ExprConcat,
-  ExprLeft,
-  ExprRight,
-  ExprTrim,
-  ExprPadStart,
-  ExprReplace,
-  ExprUpper,
-  ExprLower,
-  ExprLength,
-  ExprByteLength,
-  ExprSubstring,
-  ExprIndexOf,
-  // Numeric expressions
-  ExprAbs,
-  ExprRound,
-  ExprCeil,
-  ExprFloor,
-  // Date expressions
-  ExprYear,
-  ExprMonth,
-  ExprDay,
-  ExprHour,
-  ExprMinute,
-  ExprSecond,
-  ExprIsoWeek,
-  ExprIsoWeekStartDate,
-  ExprIsoYearMonth,
-  ExprDateDiff,
-  ExprDateAdd,
-  ExprFormatDate,
-  // Conditional expressions
-  ExprIfNull,
-  ExprNullIf,
-  ExprIs,
-  ExprSwitch,
-  ExprIf,
-  // Aggregate expressions
-  ExprCount,
-  ExprSum,
-  ExprAvg,
-  ExprMax,
-  ExprMin,
-  ExprGreatest,
-  ExprLeast,
-  // Utility expressions
-  ExprRowNum,
-  ExprRandom,
-  ExprCast,
-  ExprWindow,
-  ExprSubquery,
-} from "./types/expr";
+export * from "./types/expr";
 
 // QueryDef types
-export type {
-  QueryDef,
-  QueryDefObjectName,
-  CudOutputDef,
-  // DML
-  SelectQueryDef,
-  SelectQueryDefJoin,
-  InsertQueryDef,
-  InsertIfNotExistsQueryDef,
-  InsertIntoQueryDef,
-  UpdateQueryDef,
-  DeleteQueryDef,
-  UpsertQueryDef,
-  // DDL - Table
-  CreateTableQueryDef,
-  DropTableQueryDef,
-  RenameTableQueryDef,
-  TruncateQueryDef,
-  // DDL - Column
-  AddColumnQueryDef,
-  DropColumnQueryDef,
-  ModifyColumnQueryDef,
-  RenameColumnQueryDef,
-  // DDL - Index/Constraints
-  AddPkQueryDef,
-  DropPkQueryDef,
-  AddFkQueryDef,
-  DropFkQueryDef,
-  SwitchFkQueryDef,
-  AddIdxQueryDef,
-  DropIdxQueryDef,
-  // DDL - View/Procedure
-  CreateViewQueryDef,
-  DropViewQueryDef,
-  CreateProcQueryDef,
-  DropProcQueryDef,
-  ExecProcQueryDef,
-  // DDL - Schema
-  ClearSchemaQueryDef,
-  SchemaExistsQueryDef,
-  // DDL 타입 상수
-  DDL_TYPES,
-  DdlType,
-} from "./types/query-def";
+export * from "./types/query-def";
 
 //#endregion

package/src/schema/factory/column-builder.ts

@@ -327,8 +327,8 @@ export type ColumnBuilderRecord = Record<string, ColumnBuilder<ColumnPrimitive,
  * // { id: number; name: string; email: string | undefined; }
  * ```
  */
-export type InferColumns<T extends ColumnBuilderRecord> = {
-  [K in keyof T]: T[K] extends ColumnBuilder<infer V, any> ? V : never;
+export type InferColumns<TBuilders extends ColumnBuilderRecord> = {
+  [K in keyof TBuilders]: TBuilders[K] extends ColumnBuilder<infer V, any> ? V : never;
 };
 
 /**
@@ -336,8 +336,8 @@ export type InferColumns<T extends ColumnBuilderRecord> = {
  *
  * @template T - 컬럼 빌더 레코드 타입
  */
-export type InferColumnExprs<T extends ColumnBuilderRecord> = {
-  [K in keyof T]: T[K] extends ColumnBuilder<infer V, any> ? ExprInput<V> : never;
+export type InferColumnExprs<TBuilders extends ColumnBuilderRecord> = {
+  [K in keyof TBuilders]: TBuilders[K] extends ColumnBuilder<infer V, any> ? ExprInput<V> : never;
 };
 
 /**
@@ -347,8 +347,8 @@ export type InferColumnExprs<T extends ColumnBuilderRecord> = {
  *
  * @template T - 컬럼 빌더 레코드 타입
  */
-export type RequiredInsertKeys<T extends ColumnBuilderRecord> = {
-  [K in keyof T]: T[K]["meta"] extends infer M extends ColumnMeta
+export type RequiredInsertKeys<TBuilders extends ColumnBuilderRecord> = {
+  [K in keyof TBuilders]: TBuilders[K]["meta"] extends infer M extends ColumnMeta
     ? M["autoIncrement"] extends true
       ? never
       : M["nullable"] extends true
@@ -357,7 +357,7 @@ export type RequiredInsertKeys<T extends ColumnBuilderRecord> = {
           ? K
           : never
     : never;
-}[keyof T];
+}[keyof TBuilders];
 
 /**
  * INSERT 시 선택적 컬럼 키 추출
@@ -366,7 +366,10 @@ export type RequiredInsertKeys<T extends ColumnBuilderRecord> = {
  *
  * @template T - 컬럼 빌더 레코드 타입
  */
-export type OptionalInsertKeys<T extends ColumnBuilderRecord> = Exclude<keyof T, RequiredInsertKeys<T>>;
+export type OptionalInsertKeys<TBuilders extends ColumnBuilderRecord> = Exclude<
+  keyof TBuilders,
+  RequiredInsertKeys<TBuilders>
+>;
 
 /**
  * INSERT용 타입 추론
@@ -381,8 +384,11 @@ export type OptionalInsertKeys<T extends ColumnBuilderRecord> = Exclude<keyof T,
  * // { name: string; } & { id?: number; email?: string; status?: string; }
  * ```
  */
-export type InferInsertColumns<T extends ColumnBuilderRecord> = Pick<InferColumns<T>, RequiredInsertKeys<T>> &
-  Partial<Pick<InferColumns<T>, OptionalInsertKeys<T>>>;
+export type InferInsertColumns<TBuilders extends ColumnBuilderRecord> = Pick<
+  InferColumns<TBuilders>,
+  RequiredInsertKeys<TBuilders>
+> &
+  Partial<Pick<InferColumns<TBuilders>, OptionalInsertKeys<TBuilders>>>;
 
 /**
  * UPDATE용 타입 추론
@@ -391,7 +397,7 @@ export type InferInsertColumns<T extends ColumnBuilderRecord> = Pick<InferColumn
  *
  * @template T - 컬럼 빌더 레코드 타입
  */
-export type InferUpdateColumns<T extends ColumnBuilderRecord> = Partial<InferColumns<T>>;
+export type InferUpdateColumns<TBuilders extends ColumnBuilderRecord> = Partial<InferColumns<TBuilders>>;
 
 /**
  * 데이터 레코드에서 컬럼 빌더 레코드로 변환

package/src/schema/factory/relation-builder.ts

@@ -393,7 +393,7 @@ export type RelationBuilderRecord = Record<
  *
  * @template T - FK 또는 RelationKey 빌더 타입
  */
-export type ExtractRelationTarget<T> = T extends
+export type ExtractRelationTarget<TRelation> = TRelation extends
   | ForeignKeyBuilder<any, infer TTargetFn>
   | RelationKeyBuilder<any, infer TTargetFn>
   ? ReturnType<TTargetFn> extends TableBuilder<infer TCols, infer TRels>
@@ -411,7 +411,7 @@ export type ExtractRelationTarget<T> = T extends
  *
  * @template T - FKTarget 또는 RelationKeyTarget 빌더 타입
  */
-export type ExtractRelationTargetResult<T> = T extends
+export type ExtractRelationTargetResult<TRelation> = TRelation extends
   | ForeignKeyTargetBuilder<infer TTargetTableFn, infer TIsSingle>
   | RelationKeyTargetBuilder<infer TTargetTableFn, infer TIsSingle>
   ? ReturnType<TTargetTableFn> extends TableBuilder<infer TCols, infer TRels>

package/src/types/column.ts

@@ -131,8 +131,8 @@ export const dataTypeStrToColumnPrimitiveStr = {
  * type VarcharType = InferColumnPrimitiveFromDataType<{ type: "varchar"; length: 100 }>;  // string
  * ```
  */
-export type InferColumnPrimitiveFromDataType<T extends DataType> =
-  ColumnPrimitiveMap[(typeof dataTypeStrToColumnPrimitiveStr)[T["type"]]];
+export type InferColumnPrimitiveFromDataType<TDataType extends DataType> =
+  ColumnPrimitiveMap[(typeof dataTypeStrToColumnPrimitiveStr)[TDataType["type"]]];
 
 /**
  * 런타임 값에서 ColumnPrimitiveStr 추론

package/src/types/db-context-def.ts

@@ -79,9 +79,9 @@ export type DbContextInstance<TDef extends DbContextDef<any, any, any>> = DbCont
   };
 
 export interface DbContextConnectionMethods {
-  connect<R>(fn: () => Promise<R>, isolationLevel?: IsolationLevel): Promise<R>;
-  connectWithoutTransaction<R>(callback: () => Promise<R>): Promise<R>;
-  trans<R>(fn: () => Promise<R>, isolationLevel?: IsolationLevel): Promise<R>;
+  connect<TResult>(fn: () => Promise<TResult>, isolationLevel?: IsolationLevel): Promise<TResult>;
+  connectWithoutTransaction<TResult>(callback: () => Promise<TResult>): Promise<TResult>;
+  trans<TResult>(fn: () => Promise<TResult>, isolationLevel?: IsolationLevel): Promise<TResult>;
 }
 
 export interface DbContextDdlMethods {

package/src/utils/result-parser.ts

@@ -151,10 +151,10 @@ const YIELD_INTERVAL = 100;
  * // [{ id: 1, name: "User1", posts: [{ id: 10, title: "Post1" }, { id: 11, title: "Post2" }] }]
  * ```
  */
-export async function parseQueryResult<T>(
+export async function parseQueryResult<TRecord>(
   rawResults: Record<string, unknown>[],
   meta: ResultMeta,
-): Promise<T[] | undefined> {
+): Promise<TRecord[] | undefined> {
   // 빈 입력 처리
   if (rawResults.length === 0) {
     return undefined;
@@ -164,20 +164,20 @@ export async function parseQueryResult<T>(
 
   // JOIN이 없는 경우: 단순 타입 파싱만
   if (joinKeys.length === 0) {
-    return parseSimpleRecords<T>(rawResults, meta.columns);
+    return parseSimpleRecords<TRecord>(rawResults, meta.columns);
   }
 
   // JOIN이 있는 경우: 그룹핑 + 중첩화
-  return parseJoinedRecords<T>(rawResults, meta);
+  return parseJoinedRecords<TRecord>(rawResults, meta);
 }
 
 /**
  * JOIN 없는 단순 레코드 파싱
  */
-async function parseSimpleRecords<T>(
+async function parseSimpleRecords<TRecord>(
   rawResults: Record<string, unknown>[],
   columns: Record<string, ColumnPrimitiveStr>,
-): Promise<T[] | undefined> {
+): Promise<TRecord[] | undefined> {
   const results: Record<string, unknown>[] = [];
 
   for (let i = 0; i < rawResults.length; i++) {
@@ -195,7 +195,7 @@ async function parseSimpleRecords<T>(
   }
 
   // 빈 배열은 undefined 반환
-  return results.length > 0 ? (results as T[]) : undefined;
+  return results.length > 0 ? (results as TRecord[]) : undefined;
 }
 
 /**
@@ -213,10 +213,10 @@ function sortJoinKeysByDepth(joinKeys: string[]): string[] {
 /**
  * JOIN 있는 레코드 파싱 (재귀적 그룹핑)
  */
-async function parseJoinedRecords<T>(
+async function parseJoinedRecords<TRecord>(
   rawResults: Record<string, unknown>[],
   meta: ResultMeta,
-): Promise<T[] | undefined> {
+): Promise<TRecord[] | undefined> {
   // 1. 모든 레코드를 중첩 구조로 변환
   const nestedRecords: Record<string, unknown>[] = [];
   for (let i = 0; i < rawResults.length; i++) {
@@ -235,7 +235,7 @@ async function parseJoinedRecords<T>(
   // 4. 빈 결과 필터링
   const filteredResults = results.filter((r) => !isEmptyObject(r));
 
-  return filteredResults.length > 0 ? (filteredResults as T[]) : undefined;
+  return filteredResults.length > 0 ? (filteredResults as TRecord[]) : undefined;
 }
 
 /**