Context

type Context = {
  request: FastifyRequest;
  reply: FastifyReply;
  headers: IncomingHttpHeaders;
  createSSE: <T extends ZodObject>(events: T) => ReturnType<typeof createSSEFactory<T>>;
  naiteStore: NaiteStore;
  locale: string;
  /** buffer 모드에서 업로드된 파일 */
  bufferedFiles?: BufferedFile[];
  /** stream 모드에서 업로드된 파일 */
  uploadedFiles?: UploadedFile[];
} & AuthContext & ContextExtend;

request: FastifyRequest

reply: FastifyReply

headers: IncomingHttpHeaders

createSSE: <T extends ZodObject>(events: T) => ReturnType<typeof createSSEFactory<T>>

import { z } from "zod";

class MyModelClass extends BaseModel {
  @api()
  @stream({
    type: "sse",
    events: z.object({
      progress: z.object({ percent: z.number() }),
      complete: z.object({ result: z.string() })
    })
  })
  async processData(ctx: Context) {
    const sse = ctx.createSSE({
      progress: z.object({ percent: z.number() }),
      complete: z.object({ result: z.string() })
    });

    // 진행률 전송
    await sse.send("progress", { percent: 50 });
    
    // 완료 이벤트 전송
    await sse.send("complete", { result: "done" });
    
    return sse.getResponse();
  }
}

naiteStore: NaiteStore

locale: string

// sonamu.config.ts
export default {
  i18n: {
    defaultLocale: "ko",
    supportedLocales: ["ko", "en", "ja"]
  }
} satisfies SonamuConfig;

class PostModelClass extends BaseModel {
  @api({ httpMethod: "GET" })
  async findMany(ctx: Context) {
    const locale = ctx.locale; // "ko", "en", "ja" 중 하나

    // locale에 따라 다른 응답
    const posts = await this.getPuri("r")
      .table("posts")
      .where("locale", locale)
      .select("*");

    return posts;
  }
}

bufferedFiles?: BufferedFile[]

interface BufferedFile {
  // 파일 정보
  filename: string;       // 파일명
  mimetype: string;       // MIME 타입 (예: "image/png", "application/pdf")
  size: number;           // 파일 크기 (bytes)
  extname: string;        // 확장자 (예: "png", "pdf")

  // 파일 처리 메서드
  buffer: Buffer;                                          // 파일 Buffer (getter)
  md5(): Promise<string>;                                  // MD5 해시 생성
  saveToDisk(diskName: string, key: string): Promise<string>;  // 파일 저장 후 URL 반환
}

class FileModelClass extends BaseModel {
  @upload({ limits: { files: 10 } })
  async upload(): Promise<{ files: SonamuFile[] }> {
    const { bufferedFiles } = Sonamu.getContext();

    if (!bufferedFiles || bufferedFiles.length === 0) {
      throw new BadRequestException("파일이 업로드되지 않았습니다");
    }

    const processedFiles = await Promise.all(
      bufferedFiles.map(async (file) => {
        const md5 = await file.md5();
        const key = `${md5}.${file.extname}`;
        return {
          name: file.filename,
          url: await file.saveToDisk("fs", key),
          mime_type: file.mimetype,
          size: file.size,
        };
      })
    );

    return { files: processedFiles };
  }
}

import sharp from "sharp";

class ImageModelClass extends BaseModel {
  @upload({ limits: { files: 1 } })
  async uploadThumbnail(): Promise<{ url: string }> {
    const { bufferedFiles } = Sonamu.getContext();

    if (!bufferedFiles || bufferedFiles.length === 0) {
      throw new BadRequestException("이미지가 업로드되지 않았습니다");
    }

    const file = bufferedFiles[0];

    // Buffer로 이미지 처리 (getter 사용)
    const thumbnail = await sharp(file.buffer)
      .resize(200, 200)
      .jpeg({ quality: 80 })
      .toBuffer();

    // 처리된 이미지 저장
    const disk = Sonamu.storage.use("fs");
    const key = `thumbnails/${await file.md5()}.jpg`;
    await disk.put(key, thumbnail);

    return { url: await disk.getUrl(key) };
  }
}

uploadedFiles?: UploadedFile[]

interface UploadedFile {
  // 파일 정보
  filename: string;       // 파일명
  mimetype: string;       // MIME 타입 (예: "image/png", "application/pdf")
  size: number;           // 파일 크기 (bytes)
  extname: string;        // 확장자 (예: "png", "pdf")
  url: string;            // 저장된 파일의 URL
  signedUrl: string;      // Signed URL (만료 시간 있음)
  key: string;            // 저장소 내 키
  diskName: string;       // 저장된 디스크 이름

  // 파일 처리 메서드
  download(): Promise<Buffer>;  // 저장소에서 파일 다운로드
}

class FileModelClass extends BaseModel {
  @upload({ mode: "stream", limits: { files: 5 } })
  async uploadLargeFiles(): Promise<{ files: SonamuFile[] }> {
    const { uploadedFiles } = Sonamu.getContext();

    if (!uploadedFiles || uploadedFiles.length === 0) {
      throw new BadRequestException("파일이 업로드되지 않았습니다");
    }

    // 이미 저장소에 업로드 완료된 상태
    return {
      files: uploadedFiles.map((file) => ({
        name: file.filename,
        url: file.url,
        mime_type: file.mimetype,
        size: file.size,
      })),
    };
  }
}

// src/types.ts
declare module "sonamu" {
  interface ContextExtend {
    customProperty: string;
    helperMethod: () => void;
  }
}

// sonamu.config.ts
export default {
  server: {
    apiConfig: {
      contextProvider: async (baseContext) => {
        return {
          ...baseContext,
          customProperty: "custom value",
          helperMethod: () => console.log("helper")
        };
      }
    }
  }
} satisfies SonamuConfig;