@typegoose/typegoose
Version:
Define Mongoose models using TypeScript classes
413 lines • 40.5 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.processProp = void 0;
const tslib_1 = require("tslib");
const logSettings_1 = require("../logSettings");
const typegoose_1 = require("../typegoose");
const constants_1 = require("./constants");
const errors_1 = require("./errors");
const utils = tslib_1.__importStar(require("./utils"));
/**
* Function that is the actual processing of the prop's (used for caching)
* @param input All the options needed for prop's
*/
function processProp(input) {
const { key, target } = input;
const name = utils.getName(target);
const rawOptions = Object.assign({}, input.options);
let Type = Reflect.getMetadata(constants_1.DecoratorKeys.Type, target, key);
let propKind = input.propType ?? detectPropType(Type);
logSettings_1.logger.debug('Starting to process "%s.%s"', name, key);
utils.assertion(typeof key === 'string', () => new errors_1.CannotBeSymbolError(name, key));
// optionDeprecation(rawOptions);
{
// soft errors & "type"-alias mapping
switch (propKind) {
case constants_1.PropType.NONE:
break;
case constants_1.PropType.MAP:
case constants_1.PropType.ARRAY:
// set the "Type" to undefined if "ref" or "refPath" are defined, as an fallback in case "type" is also not defined
if (('ref' in rawOptions || 'refPath' in rawOptions) && !('type' in rawOptions)) {
Type = undefined;
}
break;
}
}
if (!utils.isNullOrUndefined(rawOptions.type)) {
logSettings_1.logger.info('Prop Option "type" is set to ', rawOptions.type);
const gotType = utils.getType(rawOptions.type);
Type = gotType.type;
if (gotType.dim > 0) {
rawOptions.dim = gotType.dim;
// Infer "type: [TYPE]" as a array, only if the PropType is not manually set or already inferred as something else
// This is useful if reflection fails or when working without "emitDecoratorMetadata"
if (utils.isNullOrUndefined(input.propType) && propKind == constants_1.PropType.NONE) {
logSettings_1.logger.debug('Detected "type" being set to a array, using PropType.ARRAY');
propKind = constants_1.PropType.ARRAY;
}
}
delete rawOptions.type;
}
// prevent "infinite" buildSchema loop / Maximum Stack size exceeded
if (Type === target.constructor) {
throw new errors_1.SelfContainingClassError(name, key);
}
// map to correct buffer type, otherwise it would result in "Mixed"
if (Type === typegoose_1.mongoose.Types.Buffer) {
Type = typegoose_1.mongoose.Schema.Types.Buffer;
}
// confirm that "PropType" is an ARRAY and if that the Type is still an *ARRAY, set them to Mixed
// for issues like https://github.com/typegoose/typegoose/issues/300
if (propKind === constants_1.PropType.ARRAY && detectPropType(Type) === constants_1.PropType.ARRAY) {
logSettings_1.logger.debug('Type is still *ARRAY, defaulting to Mixed');
Type = typegoose_1.mongoose.Schema.Types.Mixed;
}
// confirm that "PropType" is an MAP and if that the Type is still an *MAP, set them to Mixed
if (propKind === constants_1.PropType.MAP && detectPropType(Type) === constants_1.PropType.MAP) {
logSettings_1.logger.debug('Type is still *Map, defaulting to Mixed');
Type = typegoose_1.mongoose.Schema.Types.Mixed;
}
if (utils.isNotDefined(Type)) {
(0, typegoose_1.buildSchema)(Type);
}
const modelOptionsOfType = Reflect.getMetadata(constants_1.DecoratorKeys.ModelOptions, Type ?? {}) ?? {};
// throw a error when both "discriminators" as a prop-option and as a model-option are defined
if ('discriminators' in rawOptions && !utils.isNullOrUndefined(modelOptionsOfType?.options?.discriminators)) {
throw new errors_1.DuplicateOptionsError(['discriminators(prop-option)', 'discriminators(model-option)']);
}
if ('discriminators' in rawOptions || !utils.isNullOrUndefined(modelOptionsOfType?.options?.discriminators)) {
const discriminatorsToUse = rawOptions?.discriminators ?? modelOptionsOfType?.options?.discriminators;
logSettings_1.logger.debug('Found option "discriminators" in "%s.%s"', name, key);
const gotType = utils.getType(discriminatorsToUse, true);
utils.assertion(gotType.dim === 1, () => new errors_1.OptionDoesNotSupportOptionError('discriminators', 'dim', '1', `dim: ${gotType.dim}`));
const discriminators = gotType.type.map((val, index) => {
if (utils.isConstructor(val)) {
return { type: val };
}
if (typeof val === 'object') {
if (!('type' in val)) {
throw new Error(`"${name}.${key}" discriminator index "${index}" is an object, but does not contain the "type" property!`);
}
return val;
}
throw new Error(`"${name}.${key}" discriminators index "${index}" is not an object or an constructor!`);
});
const disMap = new Map(Reflect.getMetadata(constants_1.DecoratorKeys.NestedDiscriminators, target.constructor) ?? []);
disMap.set(key, discriminators);
Reflect.defineMetadata(constants_1.DecoratorKeys.NestedDiscriminators, disMap, target.constructor);
delete rawOptions.discriminators;
}
// allow setting the type asynchronously
if ('ref' in rawOptions) {
const gotType = utils.getType(rawOptions.ref);
utils.assertion(gotType.dim === 0, () => new errors_1.OptionDoesNotSupportOptionError('ref', 'dim', '0', `dim: ${gotType.dim}`));
rawOptions.ref = gotType.type;
utils.assertion(!utils.isNullOrUndefined(rawOptions.ref), () => new errors_1.RefOptionIsUndefinedError(name, key));
rawOptions.ref =
typeof rawOptions.ref === 'string'
? rawOptions.ref
: utils.isConstructor(rawOptions.ref)
? utils.getName(rawOptions.ref)
: rawOptions.ref;
}
if (utils.isWithVirtualPOP(rawOptions)) {
if (!utils.includesAllVirtualPOP(rawOptions)) {
throw new errors_1.NotAllVPOPElementsError(name, key);
}
const virtuals = new Map(Reflect.getMetadata(constants_1.DecoratorKeys.VirtualPopulate, target.constructor) ?? []);
virtuals.set(key, rawOptions);
Reflect.defineMetadata(constants_1.DecoratorKeys.VirtualPopulate, virtuals, target.constructor);
return;
}
if ('justOne' in rawOptions) {
logSettings_1.logger.warn(`Option "justOne" is defined in "${name}.${key}" but no Virtual-Populate-Options!\n` +
'Look here for more: https://typegoose.github.io/typegoose/docs/api/virtuals#virtual-populate');
}
const schemaProp = utils.getCachedSchema(input.cl);
// do this early, because the other options (enum, ref, refPath, discriminators) should not matter for this one
if (Type instanceof typegoose_1.Passthrough) {
logSettings_1.logger.debug('Type is "instanceof Passthrough" ("%s.%s", %s, direct: %s)', name, key, propKind, Type.direct);
// this is because the check above narrows down the type, which somehow is not compatible
const newType = Type.raw;
if (Type.direct) {
schemaProp[key] = newType;
return;
}
switch (propKind) {
case constants_1.PropType.ARRAY:
schemaProp[key] = utils.mapArrayOptions(rawOptions, newType, target, key);
return;
case constants_1.PropType.MAP:
const mapped = utils.mapOptions(rawOptions, newType, target, key);
schemaProp[key] = {
...mapped.outer,
type: Map,
of: { type: newType, ...mapped.inner },
};
return;
case constants_1.PropType.NONE:
schemaProp[key] = {
...rawOptions,
type: newType,
};
return;
default:
throw new errors_1.InvalidPropTypeError(propKind, name, key, 'PropType(Passthrough)');
}
}
// use "Type" if it is an suitable ref-type, otherwise default back to "ObjectId"
const refType = utils.isAnRefType(Type) ? Type : typegoose_1.mongoose.Schema.Types.ObjectId;
if ('ref' in rawOptions) {
const ref = rawOptions.ref;
delete rawOptions.ref;
switch (propKind) {
case constants_1.PropType.ARRAY:
schemaProp[key] = utils.mapArrayOptions(rawOptions, refType, target, key, undefined, { ref });
break;
case constants_1.PropType.NONE:
schemaProp[key] = {
type: refType,
ref,
...rawOptions,
};
break;
case constants_1.PropType.MAP:
const mapped = utils.mapOptions(rawOptions, refType, target, key);
schemaProp[key] = {
...mapped.outer,
type: Map,
of: {
type: refType,
ref,
...mapped.inner,
},
};
break;
default:
throw new errors_1.InvalidPropTypeError(propKind, name, key, 'PropType(ref)');
}
return;
}
if ('refPath' in rawOptions) {
const refPath = rawOptions.refPath;
delete rawOptions.refPath;
utils.assertion(typeof refPath === 'string' && refPath.length > 0, () => new errors_1.StringLengthExpectedError(1, refPath, `${name}.${key}`, 'refPath'));
switch (propKind) {
case constants_1.PropType.ARRAY:
schemaProp[key] = utils.mapArrayOptions(rawOptions, refType, target, key, undefined, { refPath });
break;
case constants_1.PropType.NONE:
schemaProp[key] = {
type: refType,
refPath,
...rawOptions,
};
break;
default:
throw new errors_1.InvalidPropTypeError(propKind, name, key, 'PropType(refPath)');
}
return;
}
// check if Type is actually a real working Type
if (utils.isNullOrUndefined(Type) || typeof Type !== 'function') {
throw new errors_1.InvalidTypeError(name, key, Type);
}
if (!utils.isNullOrUndefined(rawOptions.enum)) {
let useType = rawOptions.enum;
let inValues = false;
if (rawOptions.enum?.constructor === Object && 'values' in rawOptions.enum) {
useType = rawOptions.enum.values;
inValues = true;
}
// disabling lint line, because eslint seemingly cant handle a changing value and a unchanging value in the same destruction
// eslint-disable-next-line prefer-const
let { dim: enumDim, type: enumType } = utils.getType(useType, true);
utils.assertion(enumDim === 1 || enumDim === 0, () => new errors_1.OptionDoesNotSupportOptionError('enum', 'dim', '0 or 1', `dim: ${enumDim}`));
// check if the option is already a array (mongoose enum), if not convert it
if (!Array.isArray(enumType)) {
if (Type === String || Type === typegoose_1.mongoose.Schema.Types.String) {
enumType = Object.entries(enumType) // get all key-value pairs of the enum
// no reverse-filtering because if it is full of strings, there is no reverse mapping
.map(([enumKey, enumValue]) => {
// convert key-value pairs to an mongoose-usable enum
// safeguard, this should never happen because TypeScript only sets "design:type" to "String"
// if the enum is full of strings
if (typeof enumValue !== 'string') {
throw new errors_1.NotStringTypeError(name, key, enumKey, typeof enumValue);
}
return enumValue;
});
}
else if (Type === Number || Type === typegoose_1.mongoose.Schema.Types.Number) {
enumType = Object.entries(enumType) // get all key-value pairs of the enum
// filter out the "reverse (value -> name) mappings"
// https://www.typescriptlang.org/docs/handbook/enums.html#reverse-mappings
.filter(([enumKey, enumValue], _i, arr) => {
// safeguard, this should never happen because typescript only sets "design:type" to "Number"
// if the enum is full of numbers
if (utils.isNullOrUndefined(enumValue) || arr.findIndex(([k]) => k === enumValue.toString()) <= -1) {
// if there is no reverse mapping, throw an error
throw new errors_1.NotNumberTypeError(name, key, enumKey, typeof enumValue);
}
return typeof enumValue === 'number';
})
.map(([enumKey, enumValue]) => {
// convert key-value pairs to an mongoose-useable enum
if (typeof enumValue !== 'number') {
throw new errors_1.NotNumberTypeError(name, key, enumKey, typeof enumValue);
}
return enumValue;
});
}
else {
// this will happen if the enum type is not "String" or "Number"
// most likely this error happened because the code got transpiled with babel or "tsc --transpile-only"
throw new errors_1.InvalidEnumTypeError(name, key, Type);
}
}
// re-assign the option with the updated type
if (inValues) {
rawOptions.enum.values = enumType;
}
else {
rawOptions.enum = enumType;
}
}
if (!utils.isNullOrUndefined(rawOptions.addNullToEnum)) {
rawOptions.enum = Array.isArray(rawOptions.enum) ? rawOptions.enum : [];
rawOptions.enum.push(null);
delete rawOptions.addNullToEnum;
}
{
let included = utils.isWithStringValidate(rawOptions);
if (!utils.isString(Type)) {
// warn if String-Validate options are included, but is not string
utils.warnNotCorrectTypeOptions(name, key, 'String', 'String-Validate', included);
}
included = utils.isWithStringTransform(rawOptions);
if (!utils.isString(Type)) {
// warn if String-Transform options are included, but is not string
utils.warnNotCorrectTypeOptions(name, key, 'String', 'String-Transform', included);
}
included = utils.isWithNumberValidate(rawOptions);
if (!utils.isNumber(Type)) {
// warn if Number-Validate options are included, but is not number
utils.warnNotCorrectTypeOptions(name, key, 'Number', 'Number-Validate', included);
}
included = utils.isWithEnumValidate(rawOptions);
if (!utils.isString(Type) && !utils.isNumber(Type)) {
// warn if "enum" is included, but is not Number or String
utils.warnNotCorrectTypeOptions(name, key, 'String | Number', 'extra', included);
}
}
/** Is this Type (/Class) in the schemas Map? */
const hasCachedSchema = !utils.isNullOrUndefined(Reflect.getMetadata(constants_1.DecoratorKeys.CachedSchema, Type));
if (utils.isPrimitive(Type)) {
if (utils.isObject(Type, true)) {
utils.warnMixed(target, key);
}
switch (propKind) {
case constants_1.PropType.ARRAY:
schemaProp[key] = utils.mapArrayOptions(rawOptions, Type, target, key);
return;
case constants_1.PropType.MAP:
let mapped;
let finalType;
// Map the correct options for the end type
if (utils.isTypeMeantToBeArray(rawOptions)) {
mapped = utils.mapOptions(rawOptions, typegoose_1.mongoose.Schema.Types.Array, target, key);
// "rawOptions" is not used here, because that would duplicate some options to where the should not be
finalType = utils.mapArrayOptions({ ...mapped.inner, dim: rawOptions.dim }, Type, target, key);
}
else {
mapped = utils.mapOptions(rawOptions, Type, target, key);
finalType = { ...mapped.inner, type: Type };
}
schemaProp[key] = {
...mapped.outer,
type: Map,
of: { ...finalType },
};
return;
case constants_1.PropType.NONE:
schemaProp[key] = {
...rawOptions,
type: Type,
};
return;
default:
throw new errors_1.InvalidPropTypeError(propKind, name, key, 'PropType(primitive)');
}
}
// If the 'Type' is not a 'Primitive Type' and no subschema was found treat the type as 'Object'
// so that mongoose can store it as nested document
if (utils.isObject(Type) && !hasCachedSchema) {
utils.warnMixed(target, key);
logSettings_1.logger.warn('if someone can see this message, please open an new issue at https://github.com/typegoose/typegoose/issues with reproduction code for tests');
schemaProp[key] = {
...rawOptions,
type: typegoose_1.mongoose.Schema.Types.Mixed,
};
return;
}
const virtualSchema = (0, typegoose_1.buildSchema)(Type);
switch (propKind) {
case constants_1.PropType.ARRAY:
schemaProp[key] = utils.mapArrayOptions(rawOptions, virtualSchema, target, key, Type);
return;
case constants_1.PropType.MAP:
// special handling if the lower type should be an array
if ('dim' in rawOptions) {
logSettings_1.logger.debug('Map SubDocument Array for "%s.%s"', name, key);
const { type, ...outer } = utils.mapArrayOptions(rawOptions, virtualSchema, target, key, Type);
schemaProp[key] = {
...outer,
type: Map,
of: type,
};
return;
}
const mapped = utils.mapOptions(rawOptions, virtualSchema, target, key, Type);
schemaProp[key] = {
...mapped.outer,
type: Map,
of: { type: virtualSchema, ...mapped.inner },
};
return;
case constants_1.PropType.NONE:
schemaProp[key] = {
...rawOptions,
type: virtualSchema,
};
return;
default:
throw new errors_1.InvalidPropTypeError(propKind, name, key, 'PropType(subSchema)');
}
}
exports.processProp = processProp;
// The following function ("optionDeprecation") is disabled until used again
/**
* Check for deprecated options, and if needed process them
* @param options
*/
// function optionDeprecation(options: any) {}
/**
* Detect "PropType" based on "Type"
* @param Type The Type used for detection
*/
function detectPropType(Type) {
logSettings_1.logger.debug('Detecting PropType');
if (Type === Array ||
Type === typegoose_1.mongoose.Types.Array ||
Type === typegoose_1.mongoose.Schema.Types.Array ||
Type === typegoose_1.mongoose.Types.DocumentArray ||
Type === typegoose_1.mongoose.Schema.Types.DocumentArray) {
return constants_1.PropType.ARRAY;
}
if (Type === Map || Type === typegoose_1.mongoose.Types.Map || Type === typegoose_1.mongoose.Schema.Types.Map) {
return constants_1.PropType.MAP;
}
return constants_1.PropType.NONE;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"processProp.js","sourceRoot":"","sources":["../../src/internal/processProp.ts"],"names":[],"mappings":"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"}