UNPKG

@typegoose/typegoose/lib/internal/processProp.js

Version:
37.3 kBJavaScriptView Raw
1"use strict";
2Object.defineProperty(exports, "__esModule", { value: true });
3exports.processProp = void 0;
4const logSettings_1 = require("../logSettings");
5const typegoose_1 = require("../typegoose");
6const constants_1 = require("./constants");
7const errors_1 = require("./errors");
8const utils = require("./utils");
9/**
* Function that is the actual processing of the prop's (used for caching)
* @param input All the options needed for prop's
*/
13function 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);
  const 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;
      }
      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);
  }
  const enumOption = rawOptions.enum;
  if (!utils.isNullOrUndefined(enumOption)) {
      // check if the supplied value is already "mongoose-consumable"
      if (!Array.isArray(enumOption)) {
          if (Type === String || Type === typegoose_1.mongoose.Schema.Types.String) {
              rawOptions.enum = Object.entries(enumOption) // 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) {
              rawOptions.enum = Object.entries(enumOption) // 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);
          }
      }
  }
  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)');
  }
364}
365exports.processProp = processProp;
366// The following function ("optionDeprecation") is disabled until used again
367/**
* Check for deprecated options, and if needed process them
* @param options
*/
371// function optionDeprecation(options: any) {}
372/**
* Detect "PropType" based on "Type"
* @param Type The Type used for detection
*/
376function 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;
389}
390//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"processProp.js","sourceRoot":"","sources":["../../src/internal/processProp.ts"],"names":[],"mappings":"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"}
\No newline at end of file
1	`"use strict";`
2	`Object.defineProperty(exports, "__esModule", { value: true });`
3	`exports.processProp = void 0;`
4	`const logSettings_1 = require("../logSettings");`
5	`const typegoose_1 = require("../typegoose");`
6	`const constants_1 = require("./constants");`
7	`const errors_1 = require("./errors");`
8	`const utils = require("./utils");`
9	`/**`
10	`* Function that is the actual processing of the prop's (used for caching)`
11	`* @param input All the options needed for prop's`
12	`*/`
13	`function processProp(input) {`
14	`const { key, target } = input;`
15	`const name = utils.getName(target);`
16	`const rawOptions = Object.assign({}, input.options);`
17	`let Type = Reflect.getMetadata(constants_1.DecoratorKeys.Type, target, key);`
18	`const propKind = input.propType ?? detectPropType(Type);`
19	`logSettings_1.logger.debug('Starting to process "%s.%s"', name, key);`
20	`utils.assertion(typeof key === 'string', () => new errors_1.CannotBeSymbolError(name, key));`
21	`// optionDeprecation(rawOptions);`
22	`{`
23	`// soft errors & "type"-alias mapping`
24	`switch (propKind) {`
25	`case constants_1.PropType.NONE:`
26	`break;`
27	`case constants_1.PropType.MAP:`
28	`case constants_1.PropType.ARRAY:`
29	`// set the "Type" to undefined if "ref" or "refPath" are defined, as an fallback in case "type" is also not defined`
30	`if (('ref' in rawOptions \|\| 'refPath' in rawOptions) && !('type' in rawOptions)) {`
31	`Type = undefined;`
32	`}`
33	`break;`
34	`}`
35	`}`
36	`if (!utils.isNullOrUndefined(rawOptions.type)) {`
37	`logSettings_1.logger.info('Prop Option "type" is set to ', rawOptions.type);`
38	`const gotType = utils.getType(rawOptions.type);`
39	`Type = gotType.type;`
40	`if (gotType.dim > 0) {`