sonamu 0.4.13 → 0.5.0

package/src/database/puri.types.ts

@@ -0,0 +1,222 @@
+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;
+    
+// 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>;
+
+// Group By, Order By, Having 등에서 선택 가능한 컬럼
+export type ResultAvailableColumns<
+  TSchema,
+  T extends keyof TSchema | string,
+  TOriginal = any,
+  TResult = any,
+  TJoined = EmptyRecord,
+> = AvailableColumns<TSchema, T, TOriginal, TJoined> | `${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;
+
+// SQL 함수 타입 정의
+export type SqlFunction<T extends "string" | "number" | "boolean" | "date"> = {
+  _type: "sql_function";
+  _return: T;
+  _sql: string;
+};
+
+// SQL 함수 결과에서 타입 추출
+type ExtractSqlType<T> =
+  T extends SqlFunction<infer R>
+    ? R extends "string"
+      ? string
+      : R extends "number"
+        ? number
+        : R extends "boolean"
+          ? boolean
+          : R extends "date"
+            ? Date
+            : never
+    : never;
+
+// 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 함수
+
+// Select 객체 타입 정의
+export type SelectObject<
+  TSchema,
+  T extends keyof TSchema | string,
+  TOriginal = any,
+  TJoined = EmptyRecord,
+> = Record<string, SelectValue<TSchema, T, TOriginal, TJoined>>;
+
+// 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>;
+};
+
+// Where 조건 타입 (조인된 테이블 컬럼도 포함)
+export type WhereCondition<
+  TSchema,
+  T extends keyof TSchema | string,
+  TOriginal = any,
+  TJoined = EmptyRecord,
+> =
+  // 메인 테이블/서브쿼리 조건들
+  (T extends keyof TSchema
+    ? {
+        [K in keyof TSchema[T]]?: TSchema[T][K] | TSchema[T][K][];
+      }
+    : {
+        [K in keyof TOriginal]?: TOriginal[K] | TOriginal[K][];
+      }) &
+    // 조인된 테이블들의 조건들
+    (TJoined extends Record<string, any>
+      ? {
+          [K in keyof TJoined as TJoined[K] extends Record<string, any>
+            ? keyof TJoined[K] & string
+            : never]?: TJoined[K] extends Record<string, any>
+            ?
+                | TJoined[K][K extends keyof TJoined[K] ? K : never]
+                | TJoined[K][K extends keyof TJoined[K] ? K : never][]
+            : never;
+        }
+      : Record<string, never>);
+
+// 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);
+
+// Insert 타입: id, created_at 제외
+export type InsertData<T> = NullableToOptional<Omit<T, "id" | "created_at" | "__fulltext__">>;

package/src/database/transaction-context.ts

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

package/src/database/upsert-builder.ts

@@ -1,12 +1,9 @@
-import { v4 as uuidv4 } from "uuid";
+import { randomUUID } from "crypto";
 import _ from "lodash";
 import { Knex } from "knex";
-import { Kysely } from "kysely";
 import { EntityManager } from "../entity/entity-manager";
 import { nonNullable } from "../utils/utils";
 import { RowWithId, batchUpdate } from "./_batch_update";
-import { Database, DatabaseDriver, DriverSpec } from "./types";
-import { DB } from "./db";
 
 type TableData = {
   references: Set<string>;
@@ -28,7 +25,7 @@ export function isRefField(field: any): field is UBRef {
   );
 }
 
-export class UpsertBuilder<D extends DatabaseDriver> {
+export class UpsertBuilder {
   tables: Map<string, TableData>;
   constructor() {
     this.tables = new Map();
@@ -61,7 +58,7 @@ export class UpsertBuilder<D extends DatabaseDriver> {
   }
 
   register<T extends string>(
-    tableName: DriverSpec[D]["table"],
+    tableName: string,
     row: {
       [key in T]?:
         | UBRef
@@ -84,7 +81,7 @@ export class UpsertBuilder<D extends DatabaseDriver> {
           if (isRefField(val)) {
             return val.uuid;
           } else {
-            return row[unqCol as keyof typeof row] ?? uuidv4(); // nullable인 경우 uuid로 랜덤값 삽입
+            return row[unqCol as keyof typeof row] ?? randomUUID(); // nullable인 경우 uuid로 랜덤값 삽입
           }
         });
 
@@ -108,7 +105,7 @@ export class UpsertBuilder<D extends DatabaseDriver> {
       }
 
       // 찾을 수 없는 경우 생성
-      return uuidv4();
+      return randomUUID();
     })();
 
     // 모든 유니크키에 대해 유니크맵에 uuid 저장
@@ -127,7 +124,7 @@ export class UpsertBuilder<D extends DatabaseDriver> {
         rowValue.use ??= "id";
         table.references.add(rowValue.of + "." + rowValue.use);
         r[rowKey] = rowValue;
-      } else if (typeof rowValue === "object") {
+      } else if (typeof rowValue === "object" && !(rowValue instanceof Date)) {
         // object인 경우 JSON으로 변환
         r[rowKey] = rowValue === null ? null : JSON.stringify(rowValue);
       } else {
@@ -148,23 +145,23 @@ export class UpsertBuilder<D extends DatabaseDriver> {
   }
 
   async upsert(
-    wdb: DriverSpec[D]["core"],
-    tableName: DriverSpec[D]["table"],
+    wdb: Knex,
+    tableName: string,
     chunkSize?: number
   ): Promise<number[]> {
     return this.upsertOrInsert(wdb, tableName, "upsert", chunkSize);
   }
   async insertOnly(
-    wdb: DriverSpec[D]["core"],
-    tableName: DriverSpec[D]["table"],
+    wdb: Knex,
+    tableName: string,
     chunkSize?: number
   ): Promise<number[]> {
     return this.upsertOrInsert(wdb, tableName, "insert", chunkSize);
   }
 
   async upsertOrInsert(
-    _wdb: DriverSpec[D]["core"],
-    tableName: DriverSpec[D]["table"],
+    wdb: Knex,
+    tableName: string,
     mode: "upsert" | "insert",
     chunkSize?: number
   ): Promise<number[]> {
@@ -189,8 +186,6 @@ export class UpsertBuilder<D extends DatabaseDriver> {
       throw new Error(`${tableName} 해결되지 않은 참조가 있습니다.`);
     }
 
-    const wdb = DB.toClient(_wdb);
-
     // 전체 테이블 순회하여 현재 테이블 참조하는 모든 테이블 추출
     const { references, refTables } = Array.from(this.tables).reduce(
       (r, [, table]) => {
@@ -226,20 +221,18 @@ export class UpsertBuilder<D extends DatabaseDriver> {
     const uuidMap = new Map<string, any>();
 
     for (const chunk of chunks) {
+      const q = wdb.insert(chunk).into(tableName);
       if (mode === "insert") {
-        await wdb.insert(tableName, chunk);
+        await q;
       } else if (mode === "upsert") {
-        await wdb.upsert(tableName, chunk);
-        // await q.onDuplicateUpdate.apply(q, Object.keys(normalRows[0]));
+        await q.onDuplicateUpdate.apply(q, Object.keys(normalRows[0]));
       }
 
       // upsert된 row들을 다시 조회하여 uuidMap에 저장
       const uuids = chunk.map((row) => row.uuid);
-      const upsertedRows = await wdb
-        .from(tableName)
+      const upsertedRows = await wdb(tableName)
         .select(_.uniq(["uuid", "id", ...extractFields]))
-        .where(["uuid", "in", uuids])
-        .execute();
+        .whereIn("uuid", uuids);
       upsertedRows.forEach((row: any) => {
         uuidMap.set(row.uuid, row);
       });
@@ -271,19 +264,24 @@ export class UpsertBuilder<D extends DatabaseDriver> {
     if (selfRefRows.length > 0) {
       // 처리된 데이터를 제외하고 다시 upsert
       table.rows = selfRefRows;
-      const selfRefIds = await this.upsert(_wdb, tableName, chunkSize);
+      const selfRefIds = await this.upsert(wdb, tableName, chunkSize);
       allIds.push(...selfRefIds);
+    } else {
+      // 자기 참조가 없으면 해당 테이블의 데이터 초기화
+      table.rows = [];
+      table.references.clear();
+      table.uniquesMap.clear();
     }
 
     return allIds;
   }
 
   async updateBatch(
-    wdb: Knex | Kysely<Database>,
-    tableName: DriverSpec[D]["table"],
+    wdb: Knex,
+    tableName: string,
     options?: {
       chunkSize?: number;
-      where?: DriverSpec[D]["column"] | DriverSpec[D]["column"][];
+      where?: string | string[];
     }
   ): Promise<void> {
     options = _.defaults(options, {
@@ -307,12 +305,11 @@ export class UpsertBuilder<D extends DatabaseDriver> {
       return row as RowWithId<string>;
     });
 
-    await batchUpdate(
-      DB.toClient(wdb),
-      tableName,
-      whereColumns as string[],
-      rows,
-      options.chunkSize
-    );
+    await batchUpdate(wdb, tableName, whereColumns, rows, options.chunkSize);
+
+    // updateBatch 완료 후 처리된 데이터 제거
+    table.rows = [];
+    table.references.clear();
+    table.uniquesMap.clear();
   }
 }

package/src/entity/entity-manager.ts

@@ -1,12 +1,12 @@
 import chalk from "chalk";
-import glob from "glob";
+import { glob } from "fs/promises";
 import inflection from "inflection";
 import _ from "lodash";
 import path from "path";
 import { Entity } from "./entity";
 import { EntityJson } from "../types/types";
 import { Sonamu } from "../api/sonamu";
-import fs from "fs-extra";
+import { readFile } from "fs/promises";
 
 export type EntityNamesRecord = Record<
   | "fs"
@@ -40,18 +40,10 @@ class EntityManagerClass {
     );
     !doSilent && console.log(chalk.yellow(`autoload ${pathPattern}`));
 
-    return new Promise((resolve) => {
-      glob.glob(path.resolve(pathPattern!), (_err, files) => {
-        Promise.all(
-          files.map(async (file) => {
-            await this.register(JSON.parse(fs.readFileSync(file).toString()));
-          })
-        ).then(() => {
-          resolve("ok");
-          this.isAutoloaded = true;
-        });
-      });
-    });
+    for await (const file of glob(path.resolve(pathPattern!))) {
+      await this.register(JSON.parse((await readFile(file)).toString()));
+    }
+    this.isAutoloaded = true;
   }
 
   async reload(doSilent: boolean = false) {
@@ -63,7 +55,7 @@ class EntityManagerClass {
 
     const sonamuPath = path.join(
       Sonamu.apiRootPath,
-      `dist/application/sonamu.generated.js?t=${Date.now()}`
+      `dist/application/sonamu.generated.js`
     );
     // CJS
     if (require?.cache && require.cache[sonamuPath]) {

package/src/entity/entity.ts

@@ -19,11 +19,12 @@ import {
 } from "../types/types";
 import inflection from "inflection";
 import path from "path";
-import fs from "fs-extra";
+import { writeFile } from "fs/promises";
 import { z } from "zod";
 import { Sonamu } from "../api/sonamu";
 import prettier from "prettier";
 import { nonNullable } from "../utils/utils";
+import { exists } from "../utils/fs-utils";
 
 export class Entity {
   id: string;
@@ -329,37 +330,14 @@ export class Entity {
               toCol: relation.joinColumn,
             };
           } else if (isManyToManyRelationProp(relation)) {
-            const [table1, table2] = relation.joinTable.split("__");
-            const throughTables = (() => {
-              // 동일 테이블 릴레이션인 경우
-              if (this.table === relEntity.table) {
-                if (table1 === this.table) {
-                  return {
-                    fromCol: `${inflection.singularize(table1)}_id`,
-                    toCol: `${inflection.singularize(table2)}_id`,
-                  };
-                } else {
-                  return {
-                    fromCol: `${inflection.singularize(table2)}_id`,
-                    toCol: `${inflection.singularize(table1)}_id`,
-                  };
-                }
-              } else {
-                // 서로 다른 테이블인 경우 릴레이션 테이블 유지
-                return {
-                  fromCol: `${inflection.singularize(this.table)}_id`,
-                  toCol: `${inflection.singularize(relEntity.table)}_id`,
-                };
-              }
-            })();
-
             manyJoin = {
               fromTable: this.table,
               fromCol: "id",
               idField: prefix === "" ? `id` : `${prefix}__id`,
               through: {
                 table: relation.joinTable,
-                ...throughTables,
+                fromCol: `${inflection.singularize(this.table)}_id`,
+                toCol: `${inflection.singularize(relEntity.table)}_id`,
               },
               toTable: relEntity.table,
               toCol: "id",
@@ -523,7 +501,7 @@ export class Entity {
       .filter((f) => f !== null) as string[];
   }
 
-  getTableColumns(): string[] {
+  getTableColumns(): { name: string; type: string }[] {
     return this.props
       .map((prop) => {
         if (prop.type === "relation") {
@@ -531,12 +509,12 @@ export class Entity {
             prop.relationType === "BelongsToOne" ||
             (prop.relationType === "OneToOne" && prop.hasJoinColumn === true)
           ) {
-            return `${prop.name}_id`;
+            return { name: `${prop.name}_id`, type: "int_unsigned" };
           } else {
             return null;
           }
         }
-        return prop.name;
+        return { name: prop.name, type: prop.type };
       })
       .filter(nonNullable);
   }
@@ -574,7 +552,7 @@ export class Entity {
       `dist/application/${typesModulePath}.js`
     );
 
-    if (fs.existsSync(typesFileDistPath)) {
+    if (await exists(typesFileDistPath)) {
       const importPath = path.relative(__dirname, typesFileDistPath);
       const t = await import(importPath);
       this.types = Object.keys(t).reduce((result, key) => {
@@ -627,7 +605,7 @@ export class Entity {
       `src/application/${this.names.parentFs}/${this.names.fs}.entity.json`
     );
     const json = this.toJson();
-    fs.writeFileSync(
+    await writeFile(
       jsonPath,
       await prettier.format(JSON.stringify(json), {
         parser: "json",

package/src/entity/migrator-/354/235/264/354/202/254/352/260/224/354/226/264/354/232/224.md

@@ -0,0 +1 @@
+[여기](../migration/migrator.ts)로 이사갔어요.

package/src/file-storage/driver.ts

@@ -0,0 +1,121 @@
+import {
+  DeleteObjectCommand,
+  GetObjectCommand,
+  PutObjectCommand,
+  S3Client,
+  S3ClientConfig,
+} from "@aws-sdk/client-s3";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+import fs from "fs/promises";
+import path from "path";
+
+/**
+ * 파일 저장소의 공통 인터페이스
+ */
+export interface Driver {
+  put(
+    key: string,
+    contents: Buffer,
+    options?: { contentType?: string; visibility?: "public" | "private" }
+  ): Promise<void>;
+
+  del(key: string): Promise<void>;
+
+  getUrl(key: string): string;
+
+  getSignedUrl(key: string, expiresIn?: number): Promise<string>;
+}
+
+export type FSDriverConfig = {
+  location: string;
+  urlPrefix: string;
+};
+
+/**
+ * 로컬 파일시스템
+ */
+export class FSDriver implements Driver {
+  constructor(private config: FSDriverConfig) {}
+
+  async put(key: string, contents: Buffer): Promise<void> {
+    const filePath = path.join(this.config.location, key);
+    const dir = path.dirname(filePath);
+
+    await fs.mkdir(dir, { recursive: true });
+
+    await fs.writeFile(filePath, contents);
+  }
+
+  async del(key: string) {
+    await fs.rm(path.join(this.config.location, key));
+  }
+
+  getUrl(key: string): string {
+    return `${this.config.urlPrefix}/${key}`;
+  }
+
+  // 로컬 파일시스템은 signed URL을 지원하지 않으므로 일반 URL 반환
+  async getSignedUrl(key: string, _expiresIn?: number): Promise<string> {
+    return this.getUrl(key);
+  }
+}
+
+export type S3DriverConfig = S3ClientConfig & {
+  bucket: string;
+};
+
+export class S3Driver implements Driver {
+  s3: S3Client;
+
+  constructor(private config: S3DriverConfig) {
+    this.s3 = new S3Client(config);
+  }
+
+  async put(
+    key: string,
+    contents: Buffer,
+    options?: { contentType?: string; visibility?: "public" | "private" }
+  ): Promise<void> {
+    await this.s3.send(
+      new PutObjectCommand({
+        Bucket: this.config.bucket,
+        Key: key,
+        Body: contents,
+        ContentType: options?.contentType,
+        ACL: this.getAcl(options?.visibility),
+      })
+    );
+  }
+
+  async del(key: string): Promise<void> {
+    await this.s3.send(
+      new DeleteObjectCommand({
+        Bucket: this.config.bucket,
+        Key: key,
+      })
+    );
+  }
+
+  getUrl(key: string): string {
+    return `https://${this.config.bucket}.s3.${this.config.region}.amazonaws.com/${key}`;
+  }
+
+  async getSignedUrl(key: string, expiresIn?: number): Promise<string> {
+    const command = new GetObjectCommand({
+      Bucket: this.config.bucket,
+      Key: key,
+    });
+
+    return getSignedUrl(this.s3, command, {
+      expiresIn: expiresIn ?? 60 * 60 * 24 * 7,
+    });
+  }
+
+  private getAcl(visibility?: "public" | "private") {
+    if (visibility === "public") {
+      return "public-read";
+    }
+
+    return visibility;
+  }
+}