sonamu 0.7.18 → 0.7.20

package/src/api/decorators.ts

@@ -294,24 +294,19 @@ export function upload(options: UploadDecoratorOptions = {}) {
         files: [],
       };
 
-      const storage = Sonamu.storage;
-      if (!storage) {
-        throw new Error("Storage가 설정되지 않았습니다.");
-      }
-
-      const { FileStorage } = await import("../file-storage/file-storage");
+      const { UploadedFile } = await import("../storage/uploaded-file");
       if (options.mode === "multiple") {
         const rawFilesIterator = request.files();
         for await (const rawFile of rawFilesIterator) {
           if (rawFile) {
             await rawFile.toBuffer();
-            uploadContext.files.push(new FileStorage(rawFile, storage));
+            uploadContext.files.push(new UploadedFile(rawFile));
           }
         }
       } else {
         const rawFile = await request.file();
         if (rawFile) {
-          uploadContext.file = new FileStorage(rawFile, storage);
+          uploadContext.file = new UploadedFile(rawFile);
         }
       }
 

package/src/api/index.ts

@@ -1,5 +1,3 @@
-export * from "../file-storage/driver";
-export * from "../file-storage/file-storage";
 export * from "./caster";
 export * from "./code-converters";
 export * from "./context";

package/src/api/sonamu.ts

@@ -8,8 +8,8 @@ import path from "path";
 import type { ZodObject } from "zod";
 import { createMockSSEFactory, DB, isDaemonServer } from "..";
 import type { SonamuDBConfig } from "../database/db";
-import type { Driver } from "../file-storage/driver";
 import { Naite } from "../naite/naite";
+import type { StorageManager } from "../storage/storage-manager";
 import type { Syncer } from "../syncer/syncer";
 import type { WorkflowManager } from "../tasks/workflow-manager";
 import type { SonamuFastifyConfig } from "../types/types";
@@ -117,11 +117,14 @@ class SonamuClass {
     return this._secrets;
   }
 
-  private _storage: Driver | null = null;
-  set storage(storage: Driver) {
-    this._storage = storage;
-  }
-  get storage(): Driver | null {
+  private _storage: StorageManager | null = null;
+  /**
+   * StorageManager 인스턴스
+   */
+  get storage(): StorageManager {
+    if (!this._storage) {
+      throw new Error("Storage has not been initialized. Check storage config.");
+    }
     return this._storage;
   }
 
@@ -250,9 +253,10 @@ class SonamuClass {
     const server = fastify(options.fastify);
     this.server = server;
 
-    // Storage 설정 저장
+    // Storage 설정 → StorageManager 생성
     if (options.storage) {
-      this.storage = options.storage;
+      const { StorageManager } = await import("../storage/storage-manager");
+      this._storage = new StorageManager(options.storage);
     }
 
     // 플러그인 등록
@@ -714,7 +718,6 @@ class SonamuClass {
     await BaseModel.destroy();
     await this._workflows?.destroy();
     await this.watcher?.close();
-    this.storage?.destroy();
   }
 }
 export const Sonamu = new SonamuClass();

package/src/bin/cli.ts

@@ -297,13 +297,13 @@ async function fixture_init() {
   const targets = [
     {
       label: "(REMOTE) Fixture DB",
-      config: Sonamu.dbConfig.fixture_remote,
+      config: Sonamu.dbConfig.fixture,
     },
     {
       label: "(LOCAL) Testing DB",
       config: Sonamu.dbConfig.test,
       toSkip: (() => {
-        const remoteConn = Sonamu.dbConfig.fixture_remote.connection as Knex.ConnectionConfig;
+        const remoteConn = Sonamu.dbConfig.fixture.connection as Knex.ConnectionConfig;
         const localConn = Sonamu.dbConfig.test.connection as Knex.ConnectionConfig;
         return remoteConn.host === localConn.host && remoteConn.database === localConn.database;
       })(),

package/src/database/db.ts

@@ -6,15 +6,23 @@ import { Sonamu } from "../api";
 import type { DatabaseConfig, SonamuConfig } from "../api/config";
 import { TransactionContext } from "./transaction-context";
 
+/**
+ * 여러 설정 객체를 순차적으로 deep merge합니다.
+ * undefined/null인 인자는 무시됩니다.
+ */
+function mergeConfigs<T extends object>(...configs: (Partial<T> | undefined | null)[]): T {
+  return configs.reduce<T>((acc, config) => (config ? assign(acc, config as T) : acc), {} as T);
+}
+
 export type DBPreset = "w" | "r";
 
 export type SonamuDBConfig = {
   development_master: Knex.Config;
   development_slave: Knex.Config;
-  test: Knex.Config;
-  fixture_remote: Knex.Config;
   production_master: Knex.Config;
   production_slave: Knex.Config;
+  fixture: Knex.Config;
+  test: Knex.Config;
 };
 
 export class DBClass {
@@ -120,48 +128,37 @@ export class DBClass {
       config.defaultOptions,
     );
 
-    // 로컬 환경 설정
-    const test: DatabaseConfig = assign(defaultKnexConfig, {
-      connection: {
-        database: `${config.name}_test`,
-        ...config.defaultOptions?.connection,
-      },
-    });
-
-    // 개발 환경 설정
-    const devMasterOptions = config.environments?.development;
-    const devSlaveOptions = config.environments?.development_slave;
-    const development_master = assign(defaultKnexConfig, devMasterOptions ?? {});
-    const development_slave = assign(
-      assign(defaultKnexConfig, devMasterOptions ?? {}),
-      devSlaveOptions ?? {},
-    );
-    // NOTE: fixture remote는 default connection의 DB를 override해선 안됨.
-    const fixture_remote = assign(
-      assign(assign(defaultKnexConfig, devMasterOptions ?? {}), {
-        connection: {
-          database: `${config.name}_fixture_remote`,
-        },
-      }),
-      config.environments?.remote_fixture ?? {},
-    );
-
-    // 프로덕션 환경 설정
-    const prodMasterOptions = config.environments?.production ?? {};
-    const prodSlaveOptions = config.environments?.production_slave ?? {};
-    const production_master = assign(defaultKnexConfig, prodMasterOptions);
-    const production_slave = assign(
-      assign(defaultKnexConfig, prodMasterOptions),
-      prodSlaveOptions ?? {},
-    );
-
+    // biome-ignore format: 설정 구조 가독성을 위해 여러 줄로 유지
     return {
-      test,
-      fixture_remote,
-      development_master,
-      development_slave,
-      production_master,
-      production_slave,
+      // 여기에 나열한 순서대로 Sonamu UI의 DB Migration 탭에 표시됩니다.
+      test: mergeConfigs(
+        defaultKnexConfig, 
+        { connection: { database: `${config.name}_test` } },
+        config.environments?.test
+      ),
+      fixture: mergeConfigs(
+        defaultKnexConfig, 
+        { connection: { database: `${config.name}_fixture` } },
+        config.environments?.fixture,
+      ),
+      development_master: mergeConfigs(
+        defaultKnexConfig, 
+        config.environments?.development
+      ),
+      development_slave: mergeConfigs(
+        defaultKnexConfig,
+        config.environments?.development,
+        config.environments?.development_slave,
+      ),
+      production_master: mergeConfigs(
+        defaultKnexConfig, 
+        config.environments?.production
+      ),
+      production_slave: mergeConfigs(
+        defaultKnexConfig,
+        config.environments?.production,
+        config.environments?.production_slave,
+      ),
     };
   }
 

package/src/index.ts

@@ -15,7 +15,6 @@ export * from "./entity/entity";
 export * from "./entity/entity-manager";
 export * from "./exceptions/error-handler";
 export * from "./exceptions/so-exceptions";
-export * from "./file-storage/driver";
 export * from "./migration/migration-set";
 export * from "./migration/migrator";
 export * from "./migration/postgresql-schema-reader";

package/src/storage/drivers.ts

@@ -0,0 +1,15 @@
+import { FSDriver } from "flydrive/drivers/fs";
+import type { FSDriverOptions } from "flydrive/drivers/fs/types";
+import { S3Driver } from "flydrive/drivers/s3";
+import type { S3DriverOptions } from "flydrive/drivers/s3/types";
+
+/**
+ * 드라이버 팩토리 함수
+ * 설정 → 드라이버 인스턴스 생성 함수 변환
+ */
+export const drivers = {
+  fs: (config: FSDriverOptions) => () => new FSDriver(config),
+  s3: (config: S3DriverOptions) => () => new S3Driver(config),
+};
+
+export type DriverKey = keyof typeof drivers;

package/src/storage/index.ts

@@ -0,0 +1,5 @@
+// Storage 서브모듈 exports
+export { type DriverKey, drivers } from "./drivers";
+export { StorageManager } from "./storage-manager";
+export type { StorageConfig } from "./types";
+export { UploadedFile } from "./uploaded-file";

package/src/storage/storage-manager.ts

@@ -0,0 +1,39 @@
+import { Disk } from "flydrive";
+import { assertDefined } from "../utils/utils";
+import type { DriverKey } from "./drivers";
+import type { StorageConfig } from "./types";
+
+/**
+ * 여러 디스크를 관리하는 매니저
+ */
+export class StorageManager {
+  private disks: Map<DriverKey, Disk> = new Map();
+
+  constructor(private config: StorageConfig) {}
+
+  /**
+   * 디스크 인스턴스 반환 (lazy initialization)
+   * @param diskName 디스크 이름 (없으면 default)
+   */
+  use(diskName?: DriverKey): Disk {
+    const name = diskName ?? (this.config.default as DriverKey);
+
+    if (!this.disks.has(name)) {
+      const factory = this.config.drivers[name];
+      if (!factory) {
+        const available = Object.keys(this.config.drivers).join(", ");
+        throw new Error(`Unknown disk: "${name}". Available: ${available}`);
+      }
+      this.disks.set(name, new Disk(factory()));
+    }
+
+    return assertDefined(this.disks.get(name), `Disk ${name} not found`);
+  }
+
+  /**
+   * 기본 디스크 이름 반환
+   */
+  get defaultDisk(): string {
+    return this.config.default;
+  }
+}

package/src/storage/types.ts

@@ -0,0 +1,12 @@
+import type { DriverContract } from "flydrive/types";
+import type { DriverKey } from "./drivers";
+
+/**
+ * Storage 설정 타입
+ */
+export type StorageConfig = {
+  /** 기본 디스크 이름 */
+  default: string;
+  /** 디스크별 드라이버 팩토리 */
+  drivers: Record<DriverKey, () => DriverContract>;
+};

package/src/storage/uploaded-file.ts

@@ -0,0 +1,81 @@
+import type { MultipartFile } from "@fastify/multipart";
+import { createHash } from "crypto";
+import mime from "mime-types";
+import type { DriverKey } from "./drivers";
+
+/**
+ * 업로드된 파일 래퍼
+ */
+export class UploadedFile {
+  private _file: MultipartFile;
+  private _buffer?: Buffer;
+  private _url?: string;
+
+  constructor(file: MultipartFile) {
+    this._file = file;
+  }
+
+  /** 원본 파일명 */
+  get filename(): string {
+    return this._file.filename;
+  }
+
+  /** MIME 타입 */
+  get mimetype(): string {
+    return this._file.mimetype;
+  }
+
+  /** 파일 크기 (bytes) */
+  get size(): number {
+    return this._file.file.bytesRead;
+  }
+
+  /** 확장자 (점 제외) */
+  get extname(): string | false {
+    return mime.extension(this._file.mimetype);
+  }
+
+  /** saveToDisk 후 저장된 URL */
+  get url(): string | undefined {
+    return this._url;
+  }
+
+  /** Buffer로 변환 (캐싱됨) */
+  async toBuffer(): Promise<Buffer> {
+    if (!this._buffer) {
+      this._buffer = await this._file.toBuffer();
+    }
+    return this._buffer;
+  }
+
+  /** MD5 해시 계산 */
+  async md5(): Promise<string> {
+    const buffer = await this.toBuffer();
+    return createHash("md5").update(buffer).digest("hex");
+  }
+
+  /**
+   * 파일을 디스크에 저장
+   * @param key 저장 경로 (예: 'uploads/avatar.png')
+   * @param diskName 디스크 이름 (기본: default disk)
+   * @returns 저장된 파일의 URL
+   */
+  async saveToDisk(key: string, diskName?: DriverKey): Promise<string> {
+    // 순환 의존성 방지를 위해 동적 import
+    const { Sonamu } = await import("../api/sonamu");
+    const disk = Sonamu.storage.use(diskName);
+    const buffer = await this.toBuffer();
+
+    await disk.put(key, new Uint8Array(buffer), {
+      contentType: this.mimetype,
+    });
+
+    this._url = await disk.getSignedUrl(key);
+    return this._url;
+  }
+
+  /** 원본 MultipartFile 접근 */
+  get raw(): MultipartFile {
+    return this._file;
+  }
+}