타입 오류

class UserModelClass extends BaseModel {
  async delete(id: number) {  // ❌
    // delete는 JavaScript 예약어
  }
}

Unexpected token 'delete'

Error: Reserved keyword 'delete' cannot be used as method name

// ❌ 예약어 사용
async delete() { }
async switch() { }
async return() { }

// ✅ 다른 이름 사용
async remove() { }
async del() { }
async toggle() { }
async getReturn() { }

const RESERVED_KEYWORDS = [
  "break", "case", "catch", "class", "const", "continue", "debugger",
  "default", "delete", "do", "else", "enum", "export", "extends",
  "false", "finally", "for", "function", "if", "import", "in",
  "instanceof", "new", "null", "return", "super", "switch",
  "this", "throw", "true", "try", "typeof", "var", "void",
  "while", "with", "yield", "let", "static", "implements",
  "interface", "package", "private", "protected", "public",
  "await", "abstract", "as", "asserts", "any", "async",
  "boolean", "constructor", "declare", "get", "infer", "is",
  "keyof", "module", "namespace", "never", "readonly", "require",
  "number", "object", "set", "string", "symbol", "type",
  "undefined", "unique", "unknown", "from", "of"
];

const users = await UserModel.findMany();
// Type: any[]  ❌ 타입이 제대로 추론되지 않음

pnpm sonamu sync

Command Palette (Cmd+Shift+P)
> TypeScript: Restart TS Server

// src/application/sonamu.generated.ts
export type UserSave = {
  id?: number;
  email: string;
  name: string;
  // ...
};

class UserModelClass extends BaseModel {
  async findByEmail(email: string) {
    return this.findOne({ email });
    // Error: Property 'findOne' does not exist on type 'UserModelClass'
  }
}

{
  "properties": {
    "id": { "type": "id" },
    "email": { "type": "string" },
    "name": { "type": "string" }
  }
}

class UserModelClass extends BaseModel<User, UserSave> {
  entityName = "User" as const;
  // ...
}

export const UserModel = new UserModelClass();

pnpm sonamu sync

type OrderStatus = "pending" | "processing" | "completed";

class OrderModelClass extends BaseModel {
  async updateStatus(id: number, status: string) {  // ❌
    // status는 OrderStatus여야 함
  }
}

type OrderStatus = "pending" | "processing" | "completed";

class OrderModelClass extends BaseModel {
  async updateStatus(id: number, status: OrderStatus) {  // ✅
    return this.updateOne(
      { id },
      { status }
    );
  }
}

const UserSchema = z.object({
  email: z.string(),
  age: z.number()
});

@api()
async createUser(email: string, age: string) {  // ❌ age는 number여야 함
  // ...
}

@api()
async createUser(email: string, age: number) {  // ✅
  // Sonamu가 자동으로 Zod 검증
}

const CreateUserSchema = z.object({
  email: z.string().email(),
  age: z.number().int().positive()
});

@api({ schema: CreateUserSchema })
async createUser(data: z.infer<typeof CreateUserSchema>) {
  // 타입 안전성 보장
}

type WithTimestamps = {
  created_at: Date;
  updated_at: Date;
};

type User = {
  id: number;
  email: string;
} & WithTimestamps;  // Intersection 타입

// 타입이 복잡하게 표시됨

// 생성된 타입
type User = {
  id: number;
  email: string;
} & (WithTimestamps);  // 괄호 추가로 명확성 향상

pnpm add sonamu@latest
pnpm sonamu sync

type EventName = `user:${string}`;

// Zod v4에서 template literal 타입 사용 시 오류

// entity.json
{
  "columns": {
    "event_name": {
      "type": "string",
      "literalType": "user:${string}"  // 자동으로 처리됨
    }
  }
}

z.literal(`user:$\{string}`)  // 올바르게 escape됨

// user.model.ts
export class UserModelClass extends BaseModel {
  // ...
}
export type User = { ... posts: Post[] };

// post.model.ts
export class PostModelClass extends BaseModel {
  // ...
}
export type Post = { ... author: User };

// Error: Circular dependency detected

// user.model.ts
import type { Post } from "../post/post.model";

export type User = {
  id: number;
  email: string;
  posts: Post[];
};

// post.model.ts
import type { User } from "../user/user.model";

export type Post = {
  id: number;
  title: string;
  author: User;
};

// types/index.ts
export type { User } from "../application/user/user.model";
export type { Post } from "../application/post/post.model";

// 다른 파일에서 사용
import type { User, Post } from "@/types";

@api()
@upload({ mode: "single" })
async uploadFile() {
  const { file } = Sonamu.getUploadContext();
  // Type: UploadedFile | undefined
  
  const buffer = file.buffer;  // ❌ Property 'buffer' does not exist
}

@api()
@upload({ mode: "single" })
async uploadFile() {
  const { file } = Sonamu.getUploadContext();
  
  if (!file) {
    throw new BadRequestException("파일이 필요합니다");
  }
  
  // ✅ toBuffer() 메서드 사용
  const buffer = await file.toBuffer();
  
  // 또는 파일 저장
  const url = await file.saveToDisk(`uploads/${file.filename}`);
  
  return { url, size: file.size };
}

function isUser(value: any): boolean {  // ❌
  return value && typeof value.id === "number";
}

if (isUser(data)) {
  console.log(data.email);  // Error: Property 'email' does not exist
}

function isUser(value: any): value is User {  // ✅
  return (
    value &&
    typeof value.id === "number" &&
    typeof value.email === "string"
  );
}

if (isUser(data)) {
  console.log(data.email);  // ✅ 타입 안전
}

async function fetchData<T>(url: string): Promise<T> {
  const response = await fetch(url);
  return response.json();  // Type: any
}

const users = await fetchData("/api/users");
// Type: unknown  ❌

const users = await fetchData<User[]>("/api/users");
// Type: User[]  ✅

async function fetchData<T>(
  url: string,
  validator: (data: unknown) => data is T
): Promise<T> {
  const response = await fetch(url);
  const data = await response.json();
  
  if (!validator(data)) {
    throw new Error("Invalid data format");
  }
  
  return data;
}

// 사용
const users = await fetchData("/api/users", isUserArray);