分离实体定义

定义架构

你可以使用装饰器在模型中定义实体及其列。 但有些人更喜欢在单独的文件中定义一个实体及其列，这些文件在TypeORM中称为”entity schemas”。

简单定义示例：

import {EntitySchema} from "typeorm";
export const CategoryEntity = new EntitySchema({
    name: "category",
    columns: {
        id: {
            type: Number,
            primary: true,
            generated: true
        },
        name: {
            type: String
        }
    }
});

关系示例：

import {EntitySchema} from "typeorm";
export const PostEntity = new EntitySchema({
    name: "post",
    columns: {
        id: {
            type: Number,
            primary: true,
            generated: true
        },
        title: {
            type: String
        },
        text: {
            type: String
        }
    },
    relations: {
        categories: {
            type: "many-to-many",
            target: "category" // CategoryEntity
        }
    }
});

复杂示例：

import {EntitySchema} from "typeorm";
export const PersonSchema = new EntitySchema({
    name: "person",
    columns: {
        id: {
            primary: true,
            type: "int",
            generated: "increment"
        },
        firstName: {
            type: String,
            length: 30
        },
        lastName: {
            type: String,
            length: 50,
            nullable: false
        },
        age: {
            type: Number,
            nullable: false
        }
    },
    checks: [
        { expression: `"firstName" <> 'John' AND "lastName" <> 'Doe'` },
        { expression: `"age" > 18` }
    ],
    indices: [
        {
            name: "IDX_TEST",
            unique: true,
            columns: [
                "firstName",
                "lastName"
            ]
        }
    ],
    uniques: [
        {
            name: "UNIQUE_TEST",
            columns: [
                "firstName",
                "lastName"
            ]
        }
    ]
});

如果要使实体类型安全，可以定义模型并在模式定义中指定它：

import {EntitySchema} from "typeorm";
export interface Category {
    id: number;
    name: string;
}
export const CategoryEntity = new EntitySchema<Category>({
    name: "category",
    columns: {
        id: {
            type: Number,
            primary: true,
            generated: true
        },
        name: {
            type: String
        }
    }
});

扩展架构

当使用Decorator方法时，很容易将基本列extend为抽象类并简单地扩展它。 例如，在BaseEntity中这样定义id，createdAt和updatedAt列。 有关更多详细信息，请参阅具体表继承的文档

当使用EntitySchema方法时该方法便不可行。 但是，你可以使用Spread Operator（```）来改善。

重新审视上面的Category示例。 你可能希望extract基本列描述并在其他模式中复用它，则可以通过以下方式完成：

import {EntitySchemaColumnOptions} from "typeorm";
export const BaseColumnSchemaPart = {
  id: {
    type: Number,
    primary: true,
    generated: true,
  } as EntitySchemaColumnOptions,
  createdAt: {
    name: 'created_at',
    type: 'timestamp with time zone',
    createDate: true,
  } as EntitySchemaColumnOptions,
  updatedAt: {
    name: 'updated_at',
    type: 'timestamp with time zone',
    updateDate: true,
  } as EntitySchemaColumnOptions,
};

现在你可以在其他模式模型中使用BaseColumnSchemaPart，如下所示：

export const CategoryEntity = new EntitySchema<Category>({
    name: "category",
    columns: {
        ...BaseColumnSchemaPart,    
        // CategoryEntity现在具有已定义的id，createdAt，updatedAt列！
        // 此外，还定义了以下新字段
        name: {
            type: String
        }
    }
});

一定要将extended列添加到Category接口（例如，通过export interface Category extend Base Entity）。

使用Schemas查询/插入数据

当然，你可以像使用装饰器一样在存储库或实体管理器中使用已定义的模式。 回顾先前定义的Category示例（带有Interface和CategoryEntity模式）以获取一些数据或操纵数据库。

// 请求数据
const categoryRepository = getRepository<Category>(CategoryEntity);
const category = await categoryRepository.findOne(1); // category is properly typed!
// 插入一条新category到数据库
const categoryDTO = {
  // 注意id是自动生成的，请参考上面的架构定义。
  name: 'new category',
};
const newCategory = await categoryRepository.save(categoryDTO);