sonamu 0.5.6 → 0.6.0

package/src/database/puri.types.ts

@@ -1,130 +1,41 @@
-export type ComparisonOperator = "=" | ">" | ">=" | "<" | "<=" | "<>" | "!=";
-export type Expand<T> = T extends any[]
-  ? { [K in keyof T[0]]: T[0][K] }[] // 배열이면 첫 번째 요소를 Expand하고 배열로 감쌈
-  : T extends object
-    ? { [K in keyof T]: T[K] }
-    : T;
+import { DatabaseSchemaExtend } from "../types/types";
+import { Puri } from "./puri";
+import { PuriWrapper } from "./puri-wrapper";
 
-// EmptyRecord가 남아있으면 AvailableColumns 추론이 제대로 되지 않음 (EmptyRecord를 {}로 변경하면 정상 동작함)
-export type MergeJoined<TExisting, TNew> = TExisting extends EmptyRecord
-  ? TNew // 첫 join: EmptyRecord 제거하고 대체
-  : TExisting & TNew; // 이후 join: 누적
-
-type DeepEqual<T, U> = [T] extends [U]
-  ? [U] extends [T]
-    ? true
-    : false
-  : false;
-type Extends<T, U> =
-  DeepEqual<T, Record<string, never>> extends true
-    ? false
-    : T extends U
-      ? true
-      : false;
-type NullableToOptional<T> = {
-  [K in keyof T as T[K] extends null | undefined ? K : never]?: Exclude<
-    T[K],
-    null | undefined
-  >;
-} & Partial<{
-  [K in keyof T as T[K] extends null | undefined ? never : K]: T[K];
-}>;
-
-// Join 등이 Empty 상태일 떄 {}가 아니라 EmptyRecord를 써서
-export type EmptyRecord = Record<string, never>;
+// 메타데이터 컬럼 제외
+type ExcludeMetadataColumns<T> = Exclude<T, "__fulltext__">;
 
+// TTables의 모든 테이블에서 사용 가능한 컬럼 경로
+export type AvailableColumns<TTables extends Record<string, any>> =
+  | {
+      [TAlias in keyof TTables]: `${TAlias & string}.${ExcludeMetadataColumns<keyof TTables[TAlias]> & string}`;
+    }[keyof TTables]
+  | (IsSingleKey<TTables> extends true
+      ? ExcludeMetadataColumns<keyof TTables[keyof TTables]> // 단일 테이블이면 컬럼명만도 허용
+      : never);
 // Group By, Order By, Having 등에서 선택 가능한 컬럼
 export type ResultAvailableColumns<
-  TSchema,
-  T extends keyof TSchema | string,
-  TOriginal = any,
+  TTables extends Record<string, any>,
   TResult = any,
-  TJoined = EmptyRecord,
-> = Exclude<
-  | AvailableColumns<TSchema, T, TOriginal, TJoined>
-  | `${keyof TResult & string}`,
-  "__fulltext__" | `${T & string}.__fulltext__`
->;
+> = AvailableColumns<TTables> | `${keyof TResult & string}`;
 
-// 사용 가능한 컬럼 경로 타입 (메인 테이블 + 조인된 테이블들)
-export type AvailableColumns<
-  TSchema,
-  T extends keyof TSchema | string,
-  TOriginal = any,
-  TJoined = EmptyRecord,
-> = T extends keyof TSchema
-  ? // 기존 테이블 케이스
-    | (Extends<TJoined, Record<string, any>> extends false
-          ? // 이게 TSchema[T]에 존재하면
-            keyof TSchema[T]
-          : {
-              [K in keyof TJoined]: TJoined[K] extends Record<string, any>
-                ? `${string & K}.${keyof TJoined[K] & string}`
-                : never;
-            }[keyof TJoined])
-      | `${T & string}.${keyof TSchema[T] & string}`
-  : // 서브쿼리 케이스 (T는 alias string)
-    | keyof TOriginal
-      | `${T & string}.${keyof TOriginal & string}`
-      | (Extends<TJoined, Record<string, any>> extends true
-          ? {
-              [K in keyof TJoined]: TJoined[K] extends Record<string, any>
-                ? `${string & K}.${keyof TJoined[K] & string}`
-                : never;
-            }[keyof TJoined]
-          : never);
-
-// 컬럼 경로에서 타입 추출
-export type ExtractColumnType<
-  TSchema,
-  T extends keyof TSchema | string,
-  Path extends string,
-  TOriginal = any,
-  TJoined = EmptyRecord,
-> = T extends keyof TSchema
-  ? // 기존 테이블 케이스
-    Path extends keyof TSchema[T]
-    ? TSchema[T][Path] // 메인 테이블 컬럼
-    : Path extends `${T & string}.${infer Column}`
-      ? Column extends keyof TSchema[T]
-        ? TSchema[T][Column]
-        : never
-      : Path extends `${infer Table}.${infer Column}`
-        ? Table extends keyof TJoined
-          ? TJoined[Table] extends Record<string, any>
-            ? Column extends keyof TJoined[Table]
-              ? TJoined[Table][Column]
-              : never
-            : never
-          : never
-        : never
-  : // 서브쿼리 케이스 (T는 alias)
-    Path extends `${T & string}.${infer Column}`
-    ? Column extends keyof TOriginal
-      ? TOriginal[Column] // 서브쿼리 alias.컬럼
-      : never
-    : Path extends `${infer Table}.${infer Column}`
-      ? Table extends keyof TJoined
-        ? TJoined[Table] extends Record<string, any>
-          ? Column extends keyof TJoined[Table]
-            ? TJoined[Table][Column]
-            : never
-          : never
-        : never
-      : Path extends keyof TOriginal
-        ? TOriginal[Path] // 서브쿼리 컬럼 직접 접근 (가장 마지막에)
-        : never;
+// Select 값 타입 확장
+export type SelectValue<TTables extends Record<string, any>> =
+  | AvailableColumns<TTables>
+  | SqlExpression<"string" | "number" | "boolean" | "date">;
 
-// SQL 함수 타입 정의
-export type SqlFunction<T extends "string" | "number" | "boolean" | "date"> = {
-  _type: "sql_function";
-  _return: T;
-  _sql: string;
-};
+// Select 객체 타입 (현재는 컬럼 경로만 지원)
+export type SelectObject<TTables extends Record<string, any>> = Record<
+  string,
+  SelectValue<TTables> // AvailableColumns 대신
+>;
 
-// SQL 함수 결과에서 타입 추출
-type ExtractSqlType<T> =
-  T extends SqlFunction<infer R>
+// Select 결과 타입 추론
+export type ParseSelectObject<
+  TTables extends Record<string, any>,
+  TSelect extends SelectObject<TTables>,
+> = {
+  [K in keyof TSelect]: TSelect[K] extends SqlExpression<infer R>
     ? R extends "string"
       ? string
       : R extends "number"
@@ -134,96 +45,95 @@ type ExtractSqlType<T> =
           : R extends "date"
             ? Date
             : never
+    : ExtractColumnType<TTables, TSelect[K] & string>;
+};
+
+// 컬럼 경로에서 타입 추출
+export type ExtractColumnType<
+  TTables extends Record<string, any>,
+  Path extends string,
+> = Path extends `${infer TAlias}.${infer TColumn}`
+  ? TAlias extends keyof TTables
+    ? TColumn extends keyof TTables[TAlias]
+      ? TTables[TAlias][TColumn]
+      : never
+    : never
+  : IsSingleKey<TTables> extends true // 추가
+    ? Path extends keyof TTables[keyof TTables]
+      ? TTables[keyof TTables][Path]
+      : never
     : never;
+// Where 조건 객체 타입
+// 예: { "u.id": 1, "u.status": "active" }
+export type WhereCondition<TTables extends Record<string, any>> = {
+  [key in AvailableColumns<TTables>]?: ExtractColumnType<TTables, key & string>;
+};
 
-// Select 값 타입 확장
-export type SelectValue<
-  TSchema,
-  T extends keyof TSchema | string,
-  TOriginal = any,
-  TJoined = EmptyRecord,
-> =
-  | AvailableColumns<TSchema, T, TOriginal, TJoined> // 기존 컬럼
-  | SqlFunction<"string" | "number" | "boolean" | "date">; // SQL 함수
+// Fulltext index 컬럼 추출 타입
+export type FulltextColumns<TTables extends Record<string, any>> = {
+  [TAlias in keyof TTables]: TTables[TAlias] extends {
+    __fulltext__: readonly (infer Col)[];
+  }
+    ? Col extends string
+      ? `${TAlias & string}.${Col}`
+      : never
+    : never;
+}[keyof TTables];
 
-// Select 객체 타입 정의
-export type SelectObject<
-  TSchema,
-  T extends keyof TSchema | string,
-  TOriginal = any,
-  TJoined = EmptyRecord,
-> = Record<string, SelectValue<TSchema, T, TOriginal, TJoined>>;
+// 비교 연산자
+export type ComparisonOperator = "=" | ">" | ">=" | "<" | "<=" | "<>" | "!=";
 
-// Select 결과 타입 추론
-export type ParseSelectObject<
-  TSchema,
-  T extends keyof TSchema | string,
-  S extends SelectObject<TSchema, T, TOriginal, TJoined>,
-  TOriginal = any,
-  TJoined = EmptyRecord,
-> = {
-  [K in keyof S]: S[K] extends SqlFunction<any>
-    ? ExtractSqlType<S[K]> // SQL 함수면 타입 추출
-    : ExtractColumnType<TSchema, T, S[K] & string, TOriginal, TJoined>;
-};
+// SQL Expression 타입 정의
+export type SqlExpression<T extends "string" | "number" | "boolean" | "date"> =
+  {
+    _type: "sql_expression"; // 또는 "computed_value"
+    _return: T;
+    _sql: string;
+  };
 
-// Where 조건 타입 (조인된 테이블 컬럼도 포함)
-export type WhereCondition<
-  TSchema,
-  T extends keyof TSchema | string,
-  TOriginal = any,
-  TJoined = EmptyRecord,
-> = {
-  [key in AvailableColumns<TSchema, T, TOriginal, TJoined>]?: ExtractColumnType<
-    TSchema,
-    T,
-    key & string,
-    TOriginal,
-    TJoined
-  >;
-};
+// 결과 타입 가독성을 위한 타입 확장
+export type Expand<T> = T extends any[]
+  ? { [K in keyof T[0]]: T[0][K] }[] // 배열이면 첫 번째 요소를 Expand하고 배열로 감쌈
+  : T extends object
+    ? { [K in keyof T]: T[K] }
+    : T;
 
-// Fulltext index 컬럼 추출 타입 (메인 테이블 + 조인된 테이블)
-export type FulltextColumns<
-  TSchema,
-  T extends keyof TSchema | string,
-  TOriginal = any,
-  TJoined = EmptyRecord,
-> = T extends keyof TSchema
-  ? // 기존 테이블 케이스
-    | (TSchema[T] extends { __fulltext__: readonly (infer Col)[] }
-          ? Col & string
-          : never)
-      | (TSchema[T] extends { __fulltext__: readonly (infer Col)[] }
-          ? `${T & string}.${Col & string}`
-          : never)
-      | (TJoined extends Record<string, any>
-          ? {
-              [K in keyof TJoined]: TJoined[K] extends {
-                __fulltext__: readonly (infer Col)[];
-              }
-                ? (Col & string) | `${string & K}.${Col & string}`
-                : never;
-            }[keyof TJoined]
-          : never)
-  : // 서브쿼리 케이스 (T는 alias)
-    | (TOriginal extends { __fulltext__: readonly (infer Col)[] }
-          ? Col & string
-          : never)
-      | (TOriginal extends { __fulltext__: readonly (infer Col)[] }
-          ? `${T & string}.${Col & string}`
-          : never)
-      | (TJoined extends Record<string, any>
-          ? {
-              [K in keyof TJoined]: TJoined[K] extends {
-                __fulltext__: readonly (infer Col)[];
-              }
-                ? (Col & string) | `${string & K}.${Col & string}`
-                : never;
-            }[keyof TJoined]
-          : never);
+type IsSingleKey<TTables extends Record<string, any>> =
+  keyof TTables extends infer K
+    ? K extends keyof TTables
+      ? keyof TTables extends K // 역방향 체크로 단일 키 확인
+        ? true
+        : false
+      : false
+    : false;
+
+export type SingleTableValue<TTables extends Record<string, any>> =
+  IsSingleKey<TTables> extends true ? TTables[keyof TTables] : never;
+
+// Nullable을 Optional로 변환
+type NullableToOptional<T> = {
+  [K in keyof T as T[K] extends null | undefined ? K : never]?: Exclude<
+    T[K],
+    null | undefined
+  >;
+} & Partial<{
+  [K in keyof T as T[K] extends null | undefined ? never : K]: T[K];
+}>;
 
 // Insert 타입: id, created_at 제외
 export type InsertData<T> = NullableToOptional<
   Omit<T, "id" | "created_at" | "__fulltext__">
 >;
+
+// SubsetQuery를 위한 타입 유틸리티
+type ExtractTTables<T extends Puri<any, any, any>> =
+  T extends Puri<any, infer TTables, any> ? TTables : never;
+export type UnionExtractedTTables<
+  SubsetKey extends string,
+  SubsetQueries extends Record<
+    SubsetKey,
+    (qbWrapper: PuriWrapper<DatabaseSchemaExtend>) => Puri<any, any, any>
+  >,
+> = {
+  [K in SubsetKey]: ExtractTTables<ReturnType<SubsetQueries[K]>>;
+}[SubsetKey];

package/src/database/transaction-context.ts

@@ -1,14 +1,14 @@
-import type { PuriWrapper } from "./puri-wrapper";
+import type { PuriTransactionWrapper } from "./puri-wrapper";
 import type { DBPreset } from "./db";
 
 export class TransactionContext {
-  private transactions: Map<DBPreset, PuriWrapper> = new Map();
+  private transactions: Map<DBPreset, PuriTransactionWrapper> = new Map();
 
-  getTransaction(preset: DBPreset): PuriWrapper | undefined {
+  getTransaction(preset: DBPreset): PuriTransactionWrapper | undefined {
     return this.transactions.get(preset);
   }
 
-  setTransaction(preset: DBPreset, trx: PuriWrapper): void {
+  setTransaction(preset: DBPreset, trx: PuriTransactionWrapper): void {
     this.transactions.set(preset, trx);
   }
 

package/src/database/upsert-builder.ts

@@ -1,5 +1,5 @@
 import { randomUUID } from "crypto";
-import _ from "lodash";
+import * as _ from "lodash-es";
 import { Knex } from "knex";
 import { EntityManager } from "../entity/entity-manager";
 import { nonNullable } from "../utils/utils";

package/src/entity/entity-manager.ts

@@ -1,12 +1,13 @@
-import chalk from "chalk";
 import { glob } from "fs/promises";
 import inflection from "inflection";
-import _ from "lodash";
+import * as _ from "lodash-es";
 import path from "path";
 import { Entity } from "./entity";
 import { EntityJson } from "../types/types";
 import { Sonamu } from "../api/sonamu";
 import { readFile } from "fs/promises";
+import { AbsolutePath } from "../utils/path-utils";
+import assert from "assert";
 
 export type EntityNamesRecord = Record<
   | "fs"
@@ -30,7 +31,7 @@ class EntityManagerClass {
   public isAutoloaded: boolean = false;
 
   // 경로 전달받아 모든 entity.json 파일 로드
-  async autoload(doSilent: boolean = false) {
+  async autoload(_: boolean = false) {
     if (this.isAutoloaded) {
       return;
     }
@@ -38,30 +39,28 @@ class EntityManagerClass {
       Sonamu.apiRootPath,
       "/src/application/**/*.entity.json"
     );
-    !doSilent && console.log(chalk.yellow(`autoload ${pathPattern}`));
 
+    let count = 0;
     for await (const file of glob(path.resolve(pathPattern!))) {
       await this.register(JSON.parse((await readFile(file)).toString()));
+      count++;
     }
+    // !doSilent &&
+    //   console.log(
+    //     chalk.gray(
+    //       `[Loading] Loaded entity definitions from "*.entity.json" files: ${count} files.`
+    //     )
+    //   );
+
     this.isAutoloaded = true;
   }
 
   async reload(doSilent: boolean = false) {
-    console.log("reload");
     this.entities.clear();
     this.modulePaths.clear();
     this.tableSpecs.clear();
     this.isAutoloaded = false;
 
-    const sonamuPath = path.join(
-      Sonamu.apiRootPath,
-      `dist/application/sonamu.generated.js`
-    );
-    // CJS
-    if (require?.cache && require.cache[sonamuPath]) {
-      delete require.cache[sonamuPath];
-    }
-
     return await this.autoload(doSilent);
   }
 
@@ -70,7 +69,6 @@ class EntityManagerClass {
     await entity.registerModulePaths();
     entity.registerTableSpecs();
     this.entities.set(json.id, entity);
-    // console.debug(chalk.cyan(`register :: ${entity.id}`));
   }
 
   get(entityId: string): Entity {
@@ -152,6 +150,12 @@ class EntityManagerClass {
       constant: inflection.underscore(entityId).toUpperCase(),
     };
   }
+
+  getEntityIdFromPath(filePath: AbsolutePath): string {
+    const matched = filePath.match(/application\/(.+)\//);
+    assert(matched?.[1]);
+    return inflection.camelize(matched[1].replace(/\-/g, "_"));
+  }
 }
 
 export const EntityManager = new EntityManagerClass();

package/src/entity/entity.ts

@@ -1,4 +1,5 @@
-import _ from "lodash";
+import * as _ from "lodash-es";
+import { createImportUrl } from "../utils/esm-utils";
 import { EntityManager as EntityManager } from "./entity-manager";
 import {
   EntityProp,
@@ -553,8 +554,8 @@ export class Entity {
     );
 
     if (await exists(typesFileDistPath)) {
-      const importPath = path.relative(__dirname, typesFileDistPath);
-      const t = await import(importPath);
+      const importUrl = createImportUrl(typesFileDistPath);
+      const t = await import(importUrl);
       this.types = Object.keys(t).reduce((result, key) => {
         EntityManager.setModulePath(key, typesModulePath);
         return {

package/src/index.ts

@@ -1,4 +1,5 @@
 export type * from "./api/context";
+export * from "./api/config";
 export * from "./api/decorators";
 export * from "./api/sonamu";
 export * from "./database/base-model";
@@ -21,6 +22,7 @@ export * from "./entity/entity";
 export * from "./migration/migrator";
 export * from "./migration/types";
 export * from "./file-storage/driver";
+export * from "./naite/naite";
 
 // export * from "./api/code-converters";
 // export * from "./entity/entity-utils";

package/src/migration/code-generation.ts

@@ -1,4 +1,4 @@
-import _ from "lodash";
+import * as _ from "lodash-es";
 import prettier from "prettier";
 import equal from "fast-deep-equal";
 import {

package/src/migration/migration-set.ts

@@ -1,6 +1,6 @@
 import { Knex } from "knex";
 import { DBColumn, DBForeign, DBIndex } from "./types";
-import _ from "lodash";
+import * as _ from "lodash-es";
 import inflection from "inflection";
 import { Entity } from "../entity/entity";
 import { EntityManager } from "../entity/entity-manager";