Context 메서드

Sonamu.getContext(): Context

// src/utils/auth-helper.ts
import { Sonamu } from "sonamu";

export function getCurrentUser() {
  const ctx = Sonamu.getContext();
  return ctx.user;
}

export function requireAuth() {
  const user = getCurrentUser();
  if (!user) {
    throw new UnauthorizedException("로그인이 필요합니다");
  }
  return user;
}

// src/models/post.model.ts
import { requireAuth } from "../utils/auth-helper";

class PostModelClass extends BaseModel {
  @api()
  async createPost(title: string, content: string) {
    // Context를 직접 받지 않아도 헬퍼 함수를 통해 사용자 정보 접근
    const user = requireAuth();
    
    return this.create({
      title,
      content,
      authorId: user.id
    });
  }
}

// src/services/notification.service.ts
import { Sonamu } from "sonamu";

export class NotificationService {
  async sendNotification(userId: number, message: string) {
    const ctx = Sonamu.getContext();
    
    // Context의 locale 정보를 사용하여 다국어 메시지 전송
    const localizedMessage = this.localize(message, ctx.locale);
    
    // 알림 전송 로직
    await this.send(userId, localizedMessage);
  }

  private localize(message: string, locale?: string) {
    // 다국어 처리 로직
    return message;
  }
}

// test/post.test.ts
import { Sonamu } from "sonamu";

describe("PostModel", () => {
  it("should create post", async () => {
    // 테스트 환경에서는 Context 없이도 동작
    const ctx = Sonamu.getContext();
    console.log(ctx.request); // null (에러 없음)
  });
});

import { runWithMockContext } from "sonamu/test";

it("should use context in test", async () => {
  await runWithMockContext(
    {
      user: { id: 1, email: "[email protected]" }
    },
    async () => {
      const ctx = Sonamu.getContext();
      expect(ctx.user?.id).toBe(1);
    }
  );
});

Sonamu.getUploadContext(): UploadContext

type UploadContext = {
  file?: UploadedFile;
  files: UploadedFile[];
};

class FileModelClass extends BaseModel {
  @api()
  @upload({ mode: "single" })
  async uploadAvatar(ctx: Context) {
    const { file } = Sonamu.getUploadContext();
    
    if (!file) {
      throw new BadRequestException("파일이 필요합니다");
    }

    // 파일 정보 확인
    console.log(file.filename);    // "avatar.jpg"
    console.log(file.mimetype);    // "image/jpeg"
    console.log(file.size);        // 102400 (bytes)
    console.log(file.extname);     // "jpg"

    // 파일 저장
    const key = `avatars/${Date.now()}_${file.filename}`;
    const url = await file.saveToDisk(key);

    return { url, filename: file.filename, size: file.size };
  }
}

class FileModelClass extends BaseModel {
  @api()
  @upload({ mode: "multiple" })
  async uploadDocuments(ctx: Context, folderId: number) {
    const { files } = Sonamu.getUploadContext();
    
    if (files.length === 0) {
      throw new BadRequestException("최소 1개 이상의 파일이 필요합니다");
    }

    const savedFiles = await Promise.all(
      files.map(async (file, i) => {
        const key = `documents/${Date.now()}_${i}_${file.filename}`;
        const url = await file.saveToDisk(key);
        return { url, filename: file.filename, size: file.size };
      })
    );

    // 파일 메타데이터 DB 저장
    await this.createMany(
      savedFiles.map((file) => ({
        folderId,
        filename: file.filename,
        url: file.url,
        size: file.size
      }))
    );

    return { count: savedFiles.length, files: savedFiles };
  }
}

// src/utils/file-helper.ts
import { Sonamu } from "sonamu";

export function getUploadedFiles() {
  const { files } = Sonamu.getUploadContext();
  return files;
}

export function validateFileTypes(allowedTypes: string[]) {
  const { files } = Sonamu.getUploadContext();
  
  for (const file of files) {
    if (!allowedTypes.includes(file.mimetype)) {
      throw new BadRequestException(
        `허용되지 않는 파일 형식입니다: ${file.mimetype}`
      );
    }
  }
}

class FileModelClass extends BaseModel {
  @api()
  @upload({ mode: "multiple" })
  async uploadImages(ctx: Context) {
    // 이미지 파일만 허용
    validateFileTypes([
      "image/jpeg",
      "image/png",
      "image/gif",
      "image/webp"
    ]);

    const files = getUploadedFiles();
    
    // 파일 처리 로직
    // ...
  }
}

class UploadedFile {
  /** 원본 파일명 */
  get filename(): string;
  
  /** MIME 타입 */
  get mimetype(): string;
  
  /** 파일 크기 (bytes) */
  get size(): number;
  
  /** 확장자 (점 제외) */
  get extname(): string | false;
  
  /** saveToDisk 후 저장된 URL (Unsigned) */
  get url(): string | undefined;
  
  /** saveToDisk 후 저장된 URL (Signed) */
  get signedUrl(): string | undefined;
  
  /** 원본 MultipartFile 접근 */
  get raw(): MultipartFile;
  
  /** Buffer로 변환 (캐싱됨) */
  async toBuffer(): Promise<Buffer>;
  
  /** MD5 해시 계산 */
  async md5(): Promise<string>;
  
  /**
   * 파일을 디스크에 저장
   * @param key 저장 경로 (예: 'uploads/avatar.png')
   * @param diskName 디스크 이름 (기본: default disk)
   * @returns 저장된 파일의 URL
   */
  async saveToDisk(key: string, diskName?: DriverKey): Promise<string>;
}

// ✅ 올바른 사용
class PostModelClass extends BaseModel {
  @api()
  async createPost(title: string) {
    const user = this.getCurrentUser(); // 같은 스택 내
    return this.create({ title, authorId: user.id });
  }

  private getCurrentUser() {
    return Sonamu.getContext().user;
  }
}

// ❌ 잘못된 사용
class PostModelClass extends BaseModel {
  @api()
  async createPost(title: string) {
    // setTimeout은 새로운 실행 스택을 생성
    setTimeout(() => {
      const ctx = Sonamu.getContext(); // Error!
    }, 1000);
  }
}

// ✅ 올바른 사용
@api()
@upload()
async uploadFile() {
  const { file } = Sonamu.getUploadContext(); // OK
}

// ❌ 잘못된 사용
@api()
async uploadFile() {
  const { file } = Sonamu.getUploadContext(); // Error!
}