06 · EntitySchema — 데코레이터를 쓰지 않는 대안

@Entity()                           // ← TypeORM에 묶임
class User {
  @PrimaryGeneratedColumn('uuid')   // ← TypeORM에 묶임
  id!: string
 
  @Column()                         // ← TypeORM에 묶임
  name!: string
}

@Entity({ name: 'users' })
class User {
  @PrimaryGeneratedColumn('uuid') id!: string
  @Column({ length: 100 }) name!: string
  @Column({ unique: true }) email!: string
  @CreateDateColumn() createdAt!: Date
}

import { EntitySchema } from 'typeorm'
 
// 도메인 모델 — POJO, TypeORM 의존성 없음
interface User {
  id: string
  name: string
  email: string
  createdAt: Date
}
 
// 인프라 — 스키마 정의
export const UserSchema = new EntitySchema<User>({
  name: 'User',                     // 엔티티 이름
  tableName: 'users',
  columns: {
    id: {
      type: 'uuid',
      primary: true,
      generated: 'uuid',
    },
    name: {
      type: 'varchar',
      length: 100,
    },
    email: {
      type: 'varchar',
      unique: true,
    },
    createdAt: {
      type: 'timestamp with time zone',
      createDate: true,             // = @CreateDateColumn
    },
  },
})

const dataSource = new DataSource({
  /* ... */
  entities: [UserSchema],           // EntitySchema 인스턴스를 그대로
})
 
const userRepo = dataSource.getRepository<User>(UserSchema)
const users = await userRepo.find()  // User[] 타입

class User {
  id!: string
  name!: string
  email!: string
  createdAt!: Date
}
 
export const UserSchema = new EntitySchema<User>({
  name: 'User',
  target: User,                     // ← 클래스 연결
  tableName: 'users',
  columns: { /* 위와 동일 */ },
})

class User {
  id!: string
  name!: string
  email!: string
  createdAt!: Date
 
  getDisplayName() {                // 도메인 메서드 (TypeORM 무관)
    return `${this.name} <${this.email}>`
  }
}
 
const user = await userRepo.findOneBy({ id: 'X' })
console.log(user.getDisplayName())  // ✅ 동작

class EntitySchema<T = any> {
  constructor(options: EntitySchemaOptions<T>)
}
 
interface EntitySchemaOptions<T> {
  name: string                            // 엔티티 이름 (필수)
  target?: Function                       // 클래스 연결 (선택)
  tableName?: string                      // DB 테이블명
  schema?: string
  database?: string
  synchronize?: boolean
  type?: 'regular' | 'view' | 'closure'   // 'view'면 ViewEntity
  expression?: string                     // view용 SQL
  columns: { [K in keyof T]?: EntitySchemaColumnOptions }
  relations?: { [K in keyof T]?: EntitySchemaRelationOptions }
  indices?: EntitySchemaIndexOptions[]
  uniques?: EntitySchemaUniqueOptions[]
  checks?: EntitySchemaCheckOptions[]
  exclusions?: EntitySchemaExclusionOptions[]
}

interface Post {
  id: string
  title: string
  author: User
}
 
export const PostSchema = new EntitySchema<Post>({
  name: 'Post',
  columns: {
    id: { type: 'uuid', primary: true, generated: 'uuid' },
    title: { type: 'varchar' },
  },
  relations: {
    author: {
      type: 'many-to-one',
      target: 'User',                 // 또는 () => UserSchema
      joinColumn: { name: 'author_id' },
      inverseSide: 'posts',
      eager: false,
      cascade: false,
      onDelete: 'CASCADE',
    },
  },
})

interface User {
  id: string
  street: string
  city: string
  zip: string
}
 
const UserSchema = new EntitySchema<User>({
  name: 'User',
  columns: {
    id: { type: 'uuid', primary: true, generated: 'uuid' },
    street: { type: 'varchar' },
    city: { type: 'varchar' },
    zip: { type: 'varchar', length: 10 },
  },
})

const addressColumns = (prefix = '') => ({
  [`${prefix}street`]: { type: 'varchar' },
  [`${prefix}city`]: { type: 'varchar' },
  [`${prefix}zip`]: { type: 'varchar', length: 10 },
} as const)
 
const OrderSchema = new EntitySchema({
  name: 'Order',
  columns: {
    id: { type: 'uuid', primary: true, generated: 'uuid' },
    ...addressColumns('shipping_'),
    ...addressColumns('billing_'),
  },
})

const UserSchema = new EntitySchema<User>({
  name: 'User',
  columns: { /* ... */ },
  indices: [
    { name: 'idx_user_email', columns: ['email'], unique: true },
    { name: 'idx_user_name', columns: ['name'] },
  ],
  uniques: [
    { name: 'uq_user_email_tenant', columns: ['email', 'tenantId'] },
  ],
  checks: [
    { expression: 'age >= 0' },
  ],
})

const UserPostCountSchema = new EntitySchema({
  name: 'UserPostCount',
  type: 'view',
  expression: `
    SELECT u.id AS user_id, COUNT(p.id) AS post_count
    FROM users u LEFT JOIN posts p ON p.author_id = u.id
    GROUP BY u.id
  `,
  columns: {
    userId: { type: 'uuid', primary: true },
    postCount: { type: 'int' },
  },
})

new EntitySchema({
  // name: 'User',         ❌ 필수
  columns: { /* ... */ },
})

class User {
  getDisplayName() { return this.name }
}
 
const UserSchema = new EntitySchema({
  name: 'User',
  // target: User,         ❌ 없으면 결과가 plain object
  columns: { /* ... */ },
})
 
const u = await repo.findOneBy({ id: 'X' })
u.getDisplayName()                  // ❌ undefined is not a function

@Entity()
class User {
  @PrimaryGeneratedColumn('uuid') id!: string
}
 
const UserSchema = new EntitySchema({
  name: 'User',
  target: User,                     // ❌ 같은 클래스에 두 메타
  columns: { /* ... */ },
})
 
new DataSource({ entities: [User, UserSchema] })

relations: {
  author: {
    type: 'many-to-one',
    target: 'user',         // ❌ EntitySchema의 'name'과 일치해야
  },
}