@tsed/mongoose 6.87.2 → 6.90.0

package/lib/index.modern.js

@@ -1,1367 +0,0 @@
-import { __decorate, __metadata, __param } from 'tslib';
-import { Inject, Injectable, registerProvider, Configuration, Module } from '@tsed/di';
-import { Logger } from '@tsed/logger';
-import mongoose, { Schema as Schema$1, Types } from 'mongoose';
-import { isArray, isString, isClass, Store, nameOf, deepMerge, cleanObject, ancestorsOf, decoratorTypeOf, useDecorators, StoreMerge, isNumber, DecoratorTypes, isArrowFn, isPlainObject } from '@tsed/core';
-import { deserialize, serialize, OnDeserialize, OnSerialize } from '@tsed/json-mapper';
-import { getProperties, Property, Example, Description, Format, Name, Pattern, JsonEntityFn, string, lazyRef, CollectionOf } from '@tsed/schema';
-import { pascalCase } from 'change-case';
-import { Formats } from '@tsed/ajv';
-
-/**
- *
- * @type {string}
- */
-const MONGOOSE_SCHEMA = "tsed:mongoose:schema";
-/**
- *
- * @type {string}
- */
-
-const MONGOOSE_SCHEMA_OPTIONS = "tsed:mongoose:schema:options";
-/**
- *
- * @type {string}
- */
-
-const MONGOOSE_MODEL = "tsed:mongoose:model";
-/**
- *
- * @type {string}
- */
-
-const MONGOOSE_MODEL_NAME = "tsed:mongoose:model:name";
-
-function asPromise(c) {
-  return c && c.asPromise ? c.asPromise() : c;
-}
-
-let MongooseService = class MongooseService {
-  constructor() {
-    this.connections = new Map();
-    this.defaultConnection = "default";
-  }
-  /**
-   *
-   * @returns {Promise<"mongoose".Connection>}
-   */
-
-
-  async connect(id, url, connectionOptions, isDefault = false) {
-    if (this.has(id)) {
-      return await this.get(id);
-    }
-
-    this.logger.info(`Connect to mongo database: ${id}`);
-    this.logger.debug(`Url: ${url}`);
-    this.logger.debug(`options: ${JSON.stringify(connectionOptions)}`);
-
-    try {
-      const connection = await asPromise(mongoose.createConnection(url, connectionOptions));
-      this.connections.set(id, connection);
-
-      if (id === "default" || isDefault) {
-        this.defaultConnection = id;
-      }
-
-      return connection;
-    } catch (er) {
-      /* istanbul ignore next */
-      this.logger.error(er);
-      /* istanbul ignore next */
-
-      process.exit();
-    }
-  }
-  /**
-   *
-   * @returns {"mongoose".Connection}
-   */
-
-
-  get(id) {
-    return this.connections.get(id || this.defaultConnection);
-  }
-  /**
-   *
-   * @param {string} id
-   * @returns {boolean}
-   */
-
-
-  has(id) {
-    return this.connections.has(id || this.defaultConnection);
-  }
-
-  async closeConnections() {
-    for (const [id, connection] of this.connections.entries()) {
-      await connection.close();
-      this.connections.delete(id);
-    }
-  }
-
-};
-
-__decorate([Inject(), __metadata("design:type", Logger)], MongooseService.prototype, "logger", void 0);
-
-MongooseService = __decorate([Injectable()], MongooseService);
-
-function _extends() {
-  _extends = Object.assign || function (target) {
-    for (var i = 1; i < arguments.length; i++) {
-      var source = arguments[i];
-
-      for (var key in source) {
-        if (Object.prototype.hasOwnProperty.call(source, key)) {
-          target[key] = source[key];
-        }
-      }
-    }
-
-    return target;
-  };
-
-  return _extends.apply(this, arguments);
-}
-
-/**
- * @ignore
- */
-// tslint:disable-next-line:variable-name
-
-const MONGOOSE_CONNECTIONS = Symbol.for("MONGOOSE_CONNECTIONS");
-
-function mapOptions(options) {
-  if (!options) {
-    return [];
-  }
-
-  if (!isArray(options)) {
-    const {
-      url,
-      connectionOptions
-    } = options || {};
-    return [{
-      id: "default",
-      url,
-      connectionOptions
-    }];
-  }
-
-  return options.map(settings => {
-    return _extends({}, settings, {
-      connectionOptions: settings.connectionOptions
-    });
-  });
-}
-
-registerProvider({
-  provide: MONGOOSE_CONNECTIONS,
-  injectable: false,
-  deps: [Configuration, MongooseService],
-
-  async useAsyncFactory(configuration, mongooseService) {
-    const settings = mapOptions(configuration.get("mongoose"));
-    let isDefault = true;
-
-    for (const current of settings) {
-      await mongooseService.connect(current.id, current.url, current.connectionOptions || {
-        useCreateIndex: true,
-        useNewUrlParser: true,
-        useUnifiedTopology: true
-      }, isDefault);
-      isDefault = false;
-    }
-
-    return mongooseService;
-  }
-
-});
-
-/**
- * @ignore
- */
-
-let MongooseModule = class MongooseModule {
-  constructor(mongooseService, settings) {
-    this.mongooseService = mongooseService;
-    this.settings = settings; // auto configure the cache manager when mongoose is used with @tsed/mongoose
-
-    const cache = this.settings.get("cache"); // istanbul ignore next
-
-    if (cache != null && cache.mongoose) {
-      cache.connection = this.mongooseService.get();
-    }
-  }
-
-  $onInit() {}
-
-  $onDestroy() {
-    return this.mongooseService.closeConnections();
-  }
-
-};
-MongooseModule = __decorate([Module({
-  imports: [MONGOOSE_CONNECTIONS]
-}), __param(1, Configuration()), __metadata("design:paramtypes", [MongooseService, Object])], MongooseModule);
-
-/**
- * @ignore
- */
-
-function resolveRefType(type) {
-  if (isString(type)) {
-    return type;
-  }
-
-  if (!isClass(type)) {
-    type = type();
-  }
-
-  return Store.from(type).get(MONGOOSE_MODEL_NAME) || nameOf(type);
-}
-
-/**
- * @ignore
- */
-
-function schemaOptions(target, options) {
-  const store = Store.from(target);
-
-  if (!store.has(MONGOOSE_SCHEMA_OPTIONS)) {
-    store.set(MONGOOSE_SCHEMA_OPTIONS, {});
-  }
-
-  if (options) {
-    store.set(MONGOOSE_SCHEMA_OPTIONS, deepMerge(store.get(MONGOOSE_SCHEMA_OPTIONS), options));
-  }
-
-  return store.get(MONGOOSE_SCHEMA_OPTIONS);
-}
-
-function mapHookArgs(hook) {
-  return [hook.method, hook.options || hook.fn, hook.options ? hook.fn : undefined].filter(Boolean);
-}
-/**
- * @ignore
- */
-
-
-function buildPreHook(fn) {
-  return fn.length === 2 ? function (next) {
-    return fn(this, next);
-  } : function (next, options) {
-    return fn(this, next, options);
-  };
-}
-/**
- * @ignore
- */
-
-function applySchemaOptions(schema, options) {
-  if (options.plugins) {
-    options.plugins.forEach(item => schema.plugin(item.plugin, item.options));
-  }
-
-  if (options.indexes) {
-    options.indexes.forEach(item => schema.index(item.fields, item.options));
-  }
-
-  if (options.pre) {
-    options.pre.forEach(item => {
-      item = _extends({}, item, {
-        fn: buildPreHook(item.fn)
-      });
-      schema.pre(...mapHookArgs(item));
-    });
-  }
-
-  if (options.post) {
-    options.post.forEach(item => schema.post(...mapHookArgs(item)));
-  }
-}
-
-const MONGOOSE_RESERVED_KEYS = ["_id"];
-/**
- * @ignore
- */
-
-function setUpSchema({
-  schema,
-  virtuals
-}, options) {
-  const mongooseSchema = new mongoose.Schema(schema, options);
-
-  for (const [key, _options] of virtuals.entries()) {
-    mongooseSchema.virtual(key, _options);
-  }
-
-  return mongooseSchema;
-}
-/**
- * @ignore
- */
-
-
-function isVirtualRef(target) {
-  return !!(target.ref && target.localField && target.foreignField);
-}
-
-function hasVersionField(schema, versionKey) {
-  // Check if versioning was disabled explicitly
-  if (!versionKey) return false; // Check for alternative version field in schema
-
-  return versionKey in schema.paths;
-}
-
-function createSchema(target, options = {}) {
-  var _options$schemaOption;
-
-  const schemaOptionsFromStore = Store.from(target).get(MONGOOSE_SCHEMA_OPTIONS) || {};
-  options.schemaOptions = _extends({}, options.schemaOptions, schemaOptionsFromStore);
-  const schema = setUpSchema(buildMongooseSchema(target), options.schemaOptions);
-  schemaOptions(target, options);
-  const outputVersionKey = hasVersionField(schema, (_options$schemaOption = options.schemaOptions) == null ? void 0 : _options$schemaOption.versionKey);
-
-  schema.methods.toClass = function toClass() {
-    return deserialize(this.toObject({
-      versionKey: outputVersionKey,
-      flattenMaps: true
-    }), {
-      type: target,
-      useAlias: false,
-      additionalProperties: true,
-      groups: false
-    });
-  };
-
-  schema.methods.toJSON = function toJSON(options) {
-    return serialize(this.toClass(), options);
-  };
-
-  schema.loadClass(target);
-  Store.from(target).set(MONGOOSE_SCHEMA, schema);
-  return schema;
-}
-/**
- * Get a schema already created. If the schema doesn't exists in registry, it'll be created.
- * @param target
- * @param options
- */
-
-function getSchema(target, options = {}) {
-  const store = Store.from(target);
-
-  if (!store.has(MONGOOSE_SCHEMA)) {
-    createSchema(target, options);
-  }
-
-  return store.get(MONGOOSE_SCHEMA);
-}
-function getSchemaToken(target, options) {
-  const collectionName = options.name || nameOf(target);
-  const token = Symbol.for(pascalCase(`${collectionName}Schema`));
-  return {
-    token,
-    collectionName
-  };
-}
-/**
- * @ignore
- */
-
-function buildMongooseSchema(target) {
-  const properties = getProperties(target, {
-    withIgnoredProps: true,
-    mongoose: true,
-    groups: false
-  });
-  const schema = {
-    schema: {},
-    virtuals: new Map()
-  };
-  properties.forEach((propertyMetadata, key) => {
-    if (MONGOOSE_RESERVED_KEYS.includes(key)) {
-      return;
-    } // Keeping the Mongoose Schema separate so it can overwrite everything once schema has been built.
-
-
-    const schemaTypeOptions = propertyMetadata.store.get(MONGOOSE_SCHEMA) || {};
-
-    if (schemaTypeOptions.schemaIgnore) {
-      return;
-    }
-
-    if (schemaTypeOptions.ref) {
-      schemaTypeOptions.ref = resolveRefType(schemaTypeOptions.ref);
-    }
-
-    if (isVirtualRef(schemaTypeOptions)) {
-      schema.virtuals.set(key, schemaTypeOptions);
-      return;
-    }
-
-    schema.schema[key] = createSchemaTypeOptions(propertyMetadata);
-  });
-  return schema;
-}
-/**
- * @ignore
- */
-
-function createSchemaTypeOptions(propEntity) {
-  const key = propEntity.propertyKey;
-  const rawMongooseSchema = propEntity.store.get(MONGOOSE_SCHEMA) || {};
-  let schemaTypeOptions = {
-    required: propEntity.required ? function () {
-      return propEntity.isRequired(this[key]);
-    } : false
-  };
-
-  if (!propEntity.isClass) {
-    const jsonSchema = propEntity.itemSchema.toJSON();
-    const {
-      minimum: min,
-      maximum: max,
-      minLength: minlength,
-      maxLength: maxlength
-    } = jsonSchema;
-    let match = jsonSchema.pattern;
-
-    if (match) {
-      match = new RegExp(match);
-    }
-
-    schemaTypeOptions = _extends({}, schemaTypeOptions, {
-      type: propEntity.type,
-      match: match,
-      min,
-      max,
-      minlength,
-      maxlength,
-      enum: jsonSchema["enum"],
-      default: jsonSchema["default"]
-    });
-  } else if (!rawMongooseSchema.ref) {
-    // References are handled by the final merge
-    schemaTypeOptions = _extends({}, schemaTypeOptions, {
-      type: getSchema(propEntity.type)
-    });
-  }
-
-  schemaTypeOptions = cleanObject(_extends({}, schemaTypeOptions, rawMongooseSchema));
-
-  if (propEntity.isCollection) {
-    if (propEntity.isArray) {
-      return [schemaTypeOptions];
-    } // Can be a Map or a Set;
-    // Mongoose implements only Map;
-
-
-    if (propEntity.collectionType !== Map) {
-      throw new Error(`Invalid collection type. ${nameOf(propEntity.collectionType)} is not supported.`);
-    }
-
-    return {
-      type: Map,
-      of: schemaTypeOptions
-    };
-  }
-
-  return schemaTypeOptions;
-}
-
-const MongooseModels = new Map();
-
-function getModelToken(target, options) {
-  const {
-    collectionName,
-    token
-  } = getSchemaToken(target, options);
-  Store.from(target).set(MONGOOSE_MODEL_NAME, collectionName);
-  MongooseModels.set(collectionName, target);
-  return {
-    token,
-    collectionName
-  };
-}
-/**
- * Create an instance of mongoose.model from a class.
- *
- * @param {Type<any>} target Class attached to the schema and model.
- * @param {"mongoose".Schema} schema Schema that will be attached to the model.
- * @param name model name
- * @param collection (optional, induced from model name)
- * @param skipInit whether to skip initialization (defaults to false)
- * @param connection
- * @param discriminatorValue
- * @returns {Model<T extends Document>}
- */
-
-function createModel(target, schema, name = nameOf(target), collection, skipInit, connection, discriminatorValue) {
-  // if ancestor has a discriminatorKey we need to link model with anscestor schema
-  const ancestor = ancestorsOf(target).find(ancestor => {
-    const options = Store.from(ancestor).get(MONGOOSE_SCHEMA_OPTIONS) || {};
-    return !!options.discriminatorKey;
-  });
-
-  if (ancestor && ancestor !== target) {
-    const ancestorModel = Store.from(ancestor).get(MONGOOSE_MODEL);
-
-    if (ancestorModel) {
-      const discriminatorName = discriminatorValue || name;
-
-      if (ancestorModel.discriminators && ancestorModel.discriminators[discriminatorName]) {
-        return ancestorModel.discriminators[discriminatorName];
-      } else {
-        return ancestorModel.discriminator(discriminatorName, schema);
-      }
-    }
-  }
-  /* istanbul ignore else */
-
-
-  if (connection) {
-    const _model = connection.model(name, schema, collection);
-
-    Store.from(target).set(MONGOOSE_MODEL, _model);
-    return _model;
-  }
-
-  const model = mongoose.model(name, schema, collection, skipInit);
-  Store.from(target).set(MONGOOSE_MODEL, model);
-  return model;
-}
-
-function Schema(options = {}) {
-  return (...parameters) => {
-    switch (decoratorTypeOf(parameters)) {
-      case "property":
-        return useDecorators(Property(), StoreMerge(MONGOOSE_SCHEMA, options))(parameters[0], parameters[1], parameters[2]);
-
-      case "class":
-        const {
-          token
-        } = getSchemaToken(parameters[0], options);
-        registerProvider({
-          provide: token,
-          deps: [],
-
-          useFactory() {
-            return getSchema(parameters[0], options);
-          }
-
-        });
-        break;
-    }
-  };
-}
-function MongooseSchema(options = {}) {
-  return Schema(options);
-}
-
-/**
- * If true, uses Mongoose's default _id settings. Only allowed for ObjectIds
- *
- * ### Example
- *
- * ```typescript
- * @Model()
- * export class EventModel {
- *   @ExcludeIndexes()
- *   field: string;
- * }
- * ```
- *
- * @param {boolean} auto
- * @returns {Function}
- * @decorator
- * @mongoose
- * @property
- */
-
-function Auto(auto = true) {
-  return MongooseSchema({
-    auto
-  });
-}
-
-/**
- * Do not apply this property to schema (create virtual property)
- *
- * ### Example
- *
- * ```typescript
- * @Model()
- * @SchemaIgnore()
- * @Property()
- * kind: string;
- *
- * ```
- *
- * @returns {Function}
- * @decorator
- * @mongoose
- * @class
- */
-
-function SchemaIgnore() {
-  return MongooseSchema({
-    schemaIgnore: true
-  });
-}
-
-function DiscriminatorKey() {
-  return useDecorators(Property(), SchemaIgnore(), (target, propertyKey) => {
-    Store.from(target).merge(MONGOOSE_SCHEMA_OPTIONS, {
-      discriminatorKey: propertyKey
-    });
-  });
-}
-
-/**
- * Define a property as mongoose reference to other Model (decorated with @Model).
- *
- * ### Example
- *
- * ```typescript
- * @Model()
- * class FooModel {
- *
- *    @DynamicRef('type')
- *    field: DynamicRef<OtherFooModel | OtherModel>
- *
- *    @Enum(['OtherFooModel', 'OtherModel'])
- *    type: string
- * }
- *
- * @Model()
- * class OtherFooModel {
- * }
- *
- * @Model()
- * class OtherModel {
- * }
- * ```
- *
- * @param refPath
- * @returns {Function}
- * @decorator
- * @mongoose
- * @property
- */
-
-function DynamicRef(refPath) {
-  return useDecorators(Property(String), Example("5ce7ad3028890bd71749d477"), Description("Mongoose Ref ObjectId"), StoreMerge(MONGOOSE_SCHEMA, {
-    type: Schema$1.Types.ObjectId,
-    refPath
-  }));
-}
-
-/**
- * If true, Mongoose will skip gathering indexes on subpaths. Only allowed for subdocuments and subdocument arrays.
- *
- * ### Example
- *
- * ```typescript
- * @Model()
- * export class EventModel {
- *   @ExcludeIndexes()
- *   field: string;
- * }
- * ```
- *
- * @param {boolean} excludeIndexes
- * @returns {Function}
- * @decorator
- * @mongoose
- * @property
- */
-
-function ExcludeIndexes(excludeIndexes = true) {
-  return MongooseSchema({
-    excludeIndexes
-  });
-}
-
-/**
- * Defines a TTL index on this path. Only allowed for dates.
- *
- * ### Example
- *
- * ```typescript
- * @Model()
- * export class EventModel {
- *   @Expires('5d')
- *   field: string;
- * }
- * ```
- *
- * @param {boolean | any} expires
- * @returns {Function}
- * @decorator
- * @mongoose
- * @property
- */
-
-function Expires(expires) {
-  return MongooseSchema({
-    expires
-  });
-}
-
-/**
- * If [truthy](https://masteringjs.io/tutorials/fundamentals/truthy), Mongoose will
- * disallow changes to this path once the document is saved to the database for the first time. Read more
- * about [immutability in Mongoose here](http://thecodebarbarian.com/whats-new-in-mongoose-5-6-immutable-properties.html).
- *
- * ### Example
- *
- * ```typescript
- * @Model()
- * export class EventModel {
- *   @Immutable()
- *   field: string;
- * }
- * ```
- *
- * @param {boolean | any} immutable
- * @returns {Function}
- * @decorator
- * @mongoose
- * @property
- */
-
-function Immutable(immutable = true) {
-  return MongooseSchema({
-    immutable
-  });
-}
-
-/**
- * Tell Mongoose whether to define an index for the property.
- * ### Example
- *
- * ```typescript
- * @Model()
- * export class EventModel {
- *   @Indexed()
- *   field: string;
- * }
- * ```
- *
- * @returns {Function}
- * @decorator
- * @mongoose
- * @property
- */
-
-function Indexed(index = true) {
-  return MongooseSchema({
-    index
-  });
-}
-
-/**
- * If truthy, Mongoose will add a custom setter that lowercases this string using JavaScript's built-in String#toLowerCase().
- *
- * ### Example
- *
- * ```typescript
- * @Model()
- * export class EventModel {
- *   @Lowercase()
- *   field: string;
- * }
- * ```
- *
- * @param {boolean} lowercase
- * @returns {Function}
- * @decorator
- * @mongoose
- * @property
- */
-
-function Lowercase(lowercase = true) {
-  return MongooseSchema({
-    lowercase
-  });
-}
-
-/**
- * Define a class as a Mongoose Model. The model can be injected to the Service, Controller, Middleware, Converters or Filter with
- * `@Inject` annotation.
- *
- * ### Example
- *
- * ```typescript
- * @Model()
- * export class EventModel {
- *   @Property()
- *   field: string;
- * }
- * ```
- *
- * Then inject the model into a service:
- *
- * ```typescript
- * class MyService {
- *    constructor(@Inject(EventModel) eventModel: MongooseModel<EventModel>) {
- *        eventModel.findById().exec();
- *    }
- * }
- * ```
- *
- * ### Options
- *
- * - `schemaOptions` (mongoose.SchemaOptions): Option to configure the schema behavior.
- * - `name` (String): model name.
- * - `collection` (String): collection (optional, induced from model name).
- * - `skipInit` (Boolean): skipInit whether to skip initialization (defaults to false).
- *
- * @param {MongooseModelOptions} options
- * @returns {(target: any) => void}
- * @decorator
- * @mongoose
- * @class
- */
-
-function Model(options = {}) {
-  return target => {
-    const {
-      token,
-      collectionName
-    } = getModelToken(target, options);
-    registerProvider({
-      provide: token,
-      deps: [],
-
-      useFactory() {
-        return getSchema(target, options);
-      }
-
-    });
-    registerProvider({
-      provide: target,
-      type: "mongoose:model",
-      deps: [MONGOOSE_CONNECTIONS, token],
-
-      useFactory(connections, schema) {
-        applySchemaOptions(schema, schemaOptions(target));
-        return createModel(target, schema, collectionName, options.collection, options.skipInit, connections.get(options.connection), options.discriminatorValue);
-      }
-
-    });
-  };
-}
-
-/**
- * Calls schema.index() to define an index (most likely compound) for the schema.
- *
- * ### Example
- *
- * ```typescript
- * @Model()
- * @MongooseIndex({first: 1, second: 1}, {unique: 1})
- * export class EventModel {
- *
- *   @Property()
- *   first: string;
- *
- *   @Property()
- *   second: string;
- *
- * }
- * ```
- *
- * @param fields
- * @param options
- * @returns {Function}
- * @decorator
- * @mongoose
- * @class
- */
-
-function MongooseIndex(fields, options) {
-  return target => {
-    schemaOptions(target, {
-      indexes: [{
-        fields,
-        options
-      }]
-    });
-  };
-}
-
-/**
- *
- * @param {(schema: "mongoose".Schema, options?: any) => void} plugin
- * @param options
- * @returns {Function}
- * @decorator
- * @mongoose
- * @class
- */
-
-function MongoosePlugin(plugin, options) {
-  return target => {
-    schemaOptions(target, {
-      plugins: [{
-        plugin,
-        options
-      }]
-    });
-  };
-}
-
-let DecimalFormat = class DecimalFormat {
-  validate(num) {
-    return isString(num) || isNumber(num);
-  }
-
-};
-DecimalFormat = __decorate([Formats("decimal", {
-  type: "number"
-})], DecimalFormat);
-
-function isDecimal(value) {
-  return value && value._bsontype === "Decimal128";
-}
-/**
- * Tell Mongoose whether to define an Decimal128 property.
- * Will be serialized as `number` with format as `decimal`.
- * ### Example
- *
- * ```typescript
- * @Model()
- * export class PriceModel {
- *   @NumberDecimal()
- *   price: Decimal128;
- * }
- * ```
- * Optionally using custom decimal type, such as `Big` from big.js
- * ```typescript
- * @Model()
- * export class PriceModel {
- *   @NumberDecimal(Big)
- *   price: Big;
- * }
- * ```
- * @param type Optional decimal type constructor
- * @decorator
- * @mongoose
- * @schema
- */
-
-
-function NumberDecimal(type) {
-  const schema = {
-    type: Schema$1.Types.Decimal128
-  };
-
-  if (type) {
-    // Define property getter to convert Decimal128 to custom type
-    schema.get = value => {
-      return isDecimal(value) ? new type(value) : value;
-    };
-  }
-
-  return useDecorators(Property(Number), Format("decimal"), Example(12.34), StoreMerge(MONGOOSE_SCHEMA, schema), // Deserialize number value from JSON to Decimal128
-  OnDeserialize(value => {
-    if (value === undefined) {
-      return undefined;
-    }
-
-    if (type) {
-      return new type(value);
-    }
-
-    if (isString(value)) {
-      return Types.Decimal128.fromString(value);
-    }
-
-    return Types.Decimal128.fromString(`${value}`);
-  }), // Serialize decimal value to floating point number
-  OnSerialize((value, ctx) => {
-    return value && Number(value);
-  }));
-}
-
-/**
- * Tell Mongoose whether to define an ObjectId property.
- * ### Example
- *
- * ```typescript
- * @Model()
- * export class EventModel {
- *   @ObjectId('id')
- *   _id: string;
- * }
- * ```
- * @param name
- * @decorator
- * @mongoose
- * @schema
- */
-
-function ObjectID(name) {
-  return useDecorators(name && Name(name), Pattern(/^[0-9a-fA-F]{24}$/), Description("Mongoose ObjectId"), Example("5ce7ad3028890bd71749d477"));
-}
-
-function PostHook(method, ...params) {
-  return (...args) => {
-    let options = params[1];
-    let fn = params[0];
-
-    if (decoratorTypeOf(args) === DecoratorTypes.METHOD_STC) {
-      options = params[0];
-      fn = args[0][args[1]].bind(args[0]);
-    }
-
-    schemaOptions(args[0], {
-      post: [{
-        method,
-        fn,
-        options
-      }]
-    });
-  };
-}
-
-/**
- *
- * We can simply attach a `@PreHook` decorator to your model class and
- * define the hook function like you normally would in Mongoose.
- *
- * ```typescript
- * import {Ignore, Required} from "@tsed/common";
- * import {PreHook, Model} from "@tsed/mongoose";
- *
- * @Model()
- * @PreHook("save", (car: CarModel, next) => {
- *    if (car.model === 'Tesla') {
- *        car.isFast = true;
- *      }
- *      next();
- *})
- * export class CarModel {
- *
- *    @Ignore()
- *    _id: string;
- *
- *    @Required()
- *    model: string;
- *
- *    @Required()
- *    isFast: boolean;
- *
- *    // or Prehook on static method
- *    @PreHook("save")
- *    static preSave(car: CarModel, next) {
- *       if (car.model === 'Tesla') {
- *           car.isFast = true;
- *       }
- *       next();
- *    }
- * }
- * ```
- *
- * This will execute the pre-save hook each time a `CarModel` document is saved.
- *
- * @param {string} method
- * @param fn
- * @param options
- * @returns {Function}
- * @decorator
- * @class
- */
-
-function PreHook(method, fn, options) {
-  return (...args) => {
-    if (decoratorTypeOf(args) === DecoratorTypes.METHOD_STC) {
-      options = fn;
-      fn = args[0][args[1]].bind(args[0]);
-    }
-
-    schemaOptions(args[0], {
-      pre: [{
-        method,
-        fn: fn,
-        options
-      }]
-    });
-  };
-}
-
-var MongooseSchemaTypes;
-
-(function (MongooseSchemaTypes) {
-  MongooseSchemaTypes["OBJECT_ID"] = "ObjectId";
-  MongooseSchemaTypes["STRING"] = "String";
-  MongooseSchemaTypes["NUMBER"] = "Number";
-})(MongooseSchemaTypes || (MongooseSchemaTypes = {}));
-
-function isRef(value) {
-  return value && value._bsontype || isString(value);
-}
-/**
- * Define a property as mongoose reference to other Model (decorated with @Model).
- *
- * ### Example
- *
- * ```typescript
- *
- * @Model()
- * class FooModel {
- *
- *    @Ref(Foo2Model)
- *    field: Ref<Foo2Model>
- *
- *    @Ref(Foo2Model)
- *    list: Ref<Foo2Model>[]
- * }
- *
- * @Model()
- * class Foo2Model {
- * }
- * ```
- *
- * @param model
- * @param type
- * @returns {Function}
- * @decorator
- * @mongoose
- * @property
- */
-
-
-function Ref(model, type = MongooseSchemaTypes.OBJECT_ID) {
-  const getType = () => isString(model) ? MongooseModels.get(model) : isArrowFn(model) ? model() : model;
-
-  return useDecorators(Property(Object), StoreMerge(MONGOOSE_SCHEMA, {
-    type: Schema$1.Types[type],
-    ref: model
-  }), OnDeserialize(value => {
-    if (isRef(value)) {
-      return value.toString();
-    }
-
-    return value;
-  }), OnSerialize((value, ctx) => {
-    if (isRef(value)) {
-      return value.toString();
-    }
-
-    const type = getType();
-    return serialize(value, _extends({}, ctx, {
-      type
-    }));
-  }), JsonEntityFn(async store => {
-    store.itemSchema.oneOf([string().example("5ce7ad3028890bd71749d477").description("Mongoose Ref ObjectId"), lazyRef(getType)]);
-    store.type = Object;
-  }));
-}
-
-/**
- * Tell Mongoose to set default select() behavior for this path.
- *
- * ### Example
- *
- * ```typescript
- * @Model()
- * export class EventModel {
- *   @Select()
- *   field: string;
- * }
- * ```
- *
- * @param {boolean | any} select
- * @returns {Function}
- * @decorator
- * @mongoose
- * @property
- */
-
-function Select(select = true) {
-  return MongooseSchema({
-    select
-  });
-}
-
-/**
- * If [truthy](https://masteringjs.io/tutorials/fundamentals/truthy), Mongoose will
- * disallow changes to this path once the document is saved to the database for the first time. Read more
- * about [immutability in Mongoose here](http://thecodebarbarian.com/whats-new-in-mongoose-5-6-immutable-properties.html).
- *
- * ### Example
- *
- * ```typescript
- * @Model()
- * export class EventModel {
- *   @Sparse()
- *   field: string;
- * }
- * ```
- *
- * @param {boolean | number} sparse
- * @returns {Function}
- * @decorator
- * @mongoose
- * @property
- */
-
-function Sparse(sparse = true) {
-  return MongooseSchema({
-    sparse
-  });
-}
-
-/**
- * If [truthy](https://masteringjs.io/tutorials/fundamentals/truthy), Mongoose
- * will build a text index on this path.
- *
- * ### Example
- *
- * ```typescript
- * @Model()
- * export class EventModel {
- *   @Text()
- *   field: string;
- * }
- * ```
- *
- * @param {boolean | number | any} text
- * @returns {Function}
- * @decorator
- * @mongoose
- * @property
- */
-
-function Text(text = true) {
-  return MongooseSchema({
-    text
-  });
-}
-
-/**
- * Tell Mongoose to make the property trimmable.
- *
- * ### Example
- *
- * ```typescript
- * @Model()
- * export class EventModel {
- *   @Trim()
- *   name: string;
- * }
- * ```
- *
- * @returns {Function}
- * @decorator
- * @mongoose
- * @property
- */
-
-function Trim() {
-  return MongooseSchema({
-    trim: true
-  });
-}
-
-/**
- * Tell Mongoose to ensure a unique index is created for this path.
- *
- * ### Example
- *
- * ```typescript
- * @Model()
- * export class EventModel {
- *   @Unique()
- *   index: string;
- * }
- * ```
- *
- * @param {boolean | any} unique
- * @returns {Function}
- * @decorator
- * @mongoose
- */
-
-function Unique(unique = true) {
-  return MongooseSchema({
-    unique
-  });
-}
-
-/**
- * If truthy, Mongoose will add a custom setter that uppercases this string using JavaScript's built-in String#toUpperCase().
- *
- * ### Example
- *
- * ```typescript
- * @Model()
- * export class EventModel {
- *   @Uppercase()
- *   field: string;
- * }
- * ```
- *
- * @param {boolean} uppercase
- * @returns {Function}
- * @decorator
- * @mongoose
- * @property
- */
-
-function Uppercase(uppercase = true) {
-  return MongooseSchema({
-    uppercase
-  });
-}
-
-function VersionKey() {
-  return (target, propertyKey) => {
-    Store.from(target).merge(MONGOOSE_SCHEMA_OPTIONS, {
-      versionKey: propertyKey
-    });
-  };
-}
-
-function getRef(opts) {
-  const ref = opts.ref || opts.type;
-  return isString(ref) ? ref : Store.from(ref).get(MONGOOSE_MODEL_NAME);
-}
-
-function getType(opts) {
-  const ref = opts.ref || opts.type;
-  return !isString(ref) ? ref : Object;
-}
-
-function getInitialOpts(options, foreignField) {
-  return isPlainObject(options) ? options : {
-    type: options,
-    foreignField
-  };
-}
-
-function mapToSchema(opts) {
-  const ref = getRef(opts);
-  const schema = {
-    ref,
-    localField: opts.localField || "_id",
-    foreignField: opts.foreignField,
-    justOne: opts.justOne || false,
-    options: opts.options
-  };
-  return schema;
-}
-
-function VirtualRef(options, foreignField) {
-  const opts = getInitialOpts(options, foreignField);
-  const schema = mapToSchema(opts);
-  const type = getType(opts);
-  return useDecorators(StoreMerge(MONGOOSE_SCHEMA, schema), type && (schema.justOne ? Property(type) : CollectionOf(type)));
-}
-
-export { Auto, DecimalFormat, DiscriminatorKey, DynamicRef, ExcludeIndexes, Expires, Immutable, Indexed, Lowercase, MONGOOSE_MODEL, MONGOOSE_MODEL_NAME, MONGOOSE_SCHEMA, MONGOOSE_SCHEMA_OPTIONS, Model, MongooseIndex, MongooseModule, MongoosePlugin, MongooseSchema, MongooseService, NumberDecimal, ObjectID, PostHook, PreHook, Ref, Schema, SchemaIgnore, Select, Sparse, Text, Trim, Unique, Uppercase, VersionKey, VirtualRef, buildMongooseSchema, createModel, createSchema, createSchemaTypeOptions, getModelToken, getSchema, getSchemaToken };
-//# sourceMappingURL=index.modern.js.map