我钻研了源码，了解了SchemaFactory.createForClass方法是如何转换Schema类的。
那么它是如何工作的？
1。看看下面这个例子：
@Schema()
export class Cat extends Document {
@Prop()
name: string;
}
export const catSchema = SchemaFactory.createForClass(Cat);
基本上，当你做SchemaFactory.createForClass(Cat)
Nest 会将类语法转换为 Mongoose 模式语法，所以最终转换的结果是这样的：
const schema = new mongoose.Schema({
name: { type: String } // Notice that `String` is now uppercase.
});
2。转换是如何进行的？
看看这个文件：mongoose/prop.decorator.ts at master · nestjs/mongoose · GitHub
export function Prop(options?: PropOptions): PropertyDecorator {
return (target: object, propertyKey: string | symbol) => {
options = (options || {}) as mongoose.SchemaTypeOpts<unknown>;
const isRawDefinition = options[RAW_OBJECT_DEFINITION];
if (!options.type && !Array.isArray(options) && !isRawDefinition) {
const type = Reflect.getMetadata(TYPE_METADATA_KEY, target, propertyKey);
if (type === Array) {
options.type = [];
} else if (type && type !== Object) {
options.type = type;
}
}
TypeMetadataStorage.addPropertyMetadata({
target: target.constructor,
propertyKey: propertyKey as string,
options,
});
};
}
在这里你可以看到 Prop() 装饰器在幕后做了什么。
当你这样做时：
@Prop()
name: string;
Prop 函数将被调用，在这种情况下没有参数。
const type = Reflect.getMetadata(TYPE_METADATA_KEY, target, propertyKey);
使用Reflect API，我们可以获取您在执行name: string 时使用的数据类型。 type 变量的值现在设置为 String。请注意，它不是string，Reflect API 将始终返回数据类型的构造函数版本，因此：
-
number 将被序列化为 Number
-
string 将被序列化为 String
-
boolean 将被序列化为 Boolean
- 等等
TypeMetadataStorage.addPropertyMetadata 然后会将下面的对象存储到存储中。
{
target: User,
propertyKey: ‘name’,
options: { type: String }
}
我们来看看：mongoose/type-metadata.storage.ts at master · nestjs/mongoose · GitHub
export class TypeMetadataStorageHost {
private schemas = new Array<SchemaMetadata>();
private properties = new Array<PropertyMetadata>();
addPropertyMetadata(metadata: PropertyMetadata) {
this.properties.push(metadata);
}
}
所以基本上该对象将存储在TypeMetadataStorageHost 中的properties 变量中。
TypeMetadataStorageHost 是一个可以存储大量此类对象的单例。
3。架构生成
要了解 SchemaFactory.createForClass(Cat) 如何生成 Mongoose 架构，请查看以下内容：mongoose/schema.factory.ts at master · nestjs/mongoose · GitHub
export class SchemaFactory {
static createForClass(target: Type<unknown>) {
const schemaDefinition = DefinitionsFactory.createForClass(target);
const schemaMetadata = TypeMetadataStorage.getSchemaMetadataByTarget(
target,
);
return new mongoose.Schema(
schemaDefinition,
schemaMetadata && schemaMetadata.options,
);
}
}
最重要的部分是：
const schemaDefinition = DefinitionsFactory.createForClass(target);。请注意，这里的目标是您的 Cat 类。
你可以在这里看到方法定义：mongoose/definitions.factory.ts at master · nestjs/mongoose · GitHub
export class DefinitionsFactory {
static createForClass(target: Type<unknown>): mongoose.SchemaDefinition {
let schemaDefinition: mongoose.SchemaDefinition = {};
schemaMetadata.properties?.forEach((item) => {
const options = this.inspectTypeDefinition(item.options as any);
schemaDefinition = {
[item.propertyKey]: options as any,
…schemaDefinition,
};
});
return schemaDefinition;
}
schemaMetadata.properties 包含您在执行TypeMetadataStorage.addPropertyMetadata 时存储的对象：
[
{
target: User,
propertyKey: ‘name’,
options: { type: String }
}
]
forEach 将产生：
{
name: { type: String }
}
最后，它将作为mongoose.Schema构造函数mongoose/schema.factory.ts at master · nestjs/mongoose · GitHub的参数：
return new mongoose.Schema(
schemaDefinition,
schemaMetadata && schemaMetadata.options,
);
4。所以回答这个问题：
你应该把什么作为Prop() 参数？
还记得 Nest 何时使用 forEach 生成 Mongoose Schema 吗？
schemaMetadata.properties?.forEach((item) => {
const options = this.inspectTypeDefinition(item.options as any);
schemaDefinition = {
[item.propertyKey]: options as any,
…schemaDefinition,
};
});
要获得options，它使用inspectTypeDefinition 方法。你可以看到下面的定义：
private static inspectTypeDefinition(options: mongoose.SchemaTypeOpts<unknown> | Function): PropOptions {
if (typeof options === 'function') {
if (this.isPrimitive(options)) {
return options;
} else if (this.isMongooseSchemaType(options)) {
return options;
}
return this.createForClass(options as Type<unknown>);
} else if (typeof options.type === 'function') {
options.type = this.inspectTypeDefinition(options.type);
return options;
} else if (Array.isArray(options)) {
return options.length > 0
? [this.inspectTypeDefinition(options[0])]
: options;
}
return options;
}
在这里你可以得出结论：
- 如果
options 是function，例如String 或SchemaType，它将直接返回并用作Mongoose 选项。
- 如果
options 是Array，它将返回该数组的第一个索引并将其包装在一个数组中。
- 如果
options不是Array或function，例如，如果它只是一个普通的object如{ type: String, required: true }，它将直接返回并用作Mongoose选项。李>
回答
所以要添加从Cat 到Owner 的引用，您可以这样做：
import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
import { Document, Schema as MongooseSchema } from 'mongoose';
import { Owner } from './owner.schema.ts';
@Schema()
export class Cat extends Document {
@Prop()
name: string;
@Prop({ type: MongooseSchema.Types.ObjectId, ref: Owner.name })
owner: Owner;
}
export const catSchema = SchemaFactory.createForClass(Cat);
至于如何将Owner的引用添加到Cat，我们可以这样做：
@Prop([{ type: MongooseSchema.Types.ObjectId, ref: Cat.name }])
更新
回答评论部分的问题：
如何将架构嵌入到另一个架构中？
如果你正确地阅读了答案，你应该有足够的知识来做到这一点。但如果您不这样做，这就是 TLDR 的答案。
请注意，我强烈建议您在前往此处之前阅读完整的答案。
image-variant.schema.ts
import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
@Schema()
export class ImageVariant {
@Prop()
url: string;
@Prop()
width: number;
@Prop()
height: number;
@Prop()
size: number;
}
export const imageVariantSchema = SchemaFactory.createForClass(ImageVariant);
image.schema.ts
import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
import { Document } from 'mongoose';
import { imageVariantSchema, ImageVariant } from './imagevariant.schema';
@Schema()
export class Image extends Document {
@Prop({ type: imageVariantSchema })
large: ImageVariant;
@Prop({ type: imageVariantSchema })
medium: ImageVariant;
@Prop({ type: imageVariantSchema })
small: ImageVariant;
}
export const imageSchema = SchemaFactory.createForClass(Image);