@tsed/mongoose 6.87.1 → 6.89.0

package/lib/index.js

@@ -1,1407 +0,0 @@
-var tslib = require('tslib');
-var di = require('@tsed/di');
-var logger = require('@tsed/logger');
-var mongoose = require('mongoose');
-var core = require('@tsed/core');
-var jsonMapper = require('@tsed/json-mapper');
-var schema = require('@tsed/schema');
-var changeCase = require('change-case');
-var ajv = require('@tsed/ajv');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var mongoose__default = /*#__PURE__*/_interopDefaultLegacy(mongoose);
-
-/**
- *
- * @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;
-}
-
-exports.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__default['default'].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);
-    }
-  }
-
-};
-
-tslib.__decorate([di.Inject(), tslib.__metadata("design:type", logger.Logger)], exports.MongooseService.prototype, "logger", void 0);
-
-exports.MongooseService = tslib.__decorate([di.Injectable()], exports.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 (!core.isArray(options)) {
-    const {
-      url,
-      connectionOptions
-    } = options || {};
-    return [{
-      id: "default",
-      url,
-      connectionOptions
-    }];
-  }
-
-  return options.map(settings => {
-    return _extends({}, settings, {
-      connectionOptions: settings.connectionOptions
-    });
-  });
-}
-
-di.registerProvider({
-  provide: MONGOOSE_CONNECTIONS,
-  injectable: false,
-  deps: [di.Configuration, exports.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
- */
-
-exports.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();
-  }
-
-};
-exports.MongooseModule = tslib.__decorate([di.Module({
-  imports: [MONGOOSE_CONNECTIONS]
-}), tslib.__param(1, di.Configuration()), tslib.__metadata("design:paramtypes", [exports.MongooseService, Object])], exports.MongooseModule);
-
-/**
- * @ignore
- */
-
-function resolveRefType(type) {
-  if (core.isString(type)) {
-    return type;
-  }
-
-  if (!core.isClass(type)) {
-    type = type();
-  }
-
-  return core.Store.from(type).get(MONGOOSE_MODEL_NAME) || core.nameOf(type);
-}
-
-/**
- * @ignore
- */
-
-function schemaOptions(target, options) {
-  const store = core.Store.from(target);
-
-  if (!store.has(MONGOOSE_SCHEMA_OPTIONS)) {
-    store.set(MONGOOSE_SCHEMA_OPTIONS, {});
-  }
-
-  if (options) {
-    store.set(MONGOOSE_SCHEMA_OPTIONS, core.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__default['default'].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 = core.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 jsonMapper.deserialize(this.toObject({
-      versionKey: outputVersionKey,
-      flattenMaps: true
-    }), {
-      type: target,
-      useAlias: false,
-      additionalProperties: true,
-      groups: false
-    });
-  };
-
-  schema.methods.toJSON = function toJSON(options) {
-    return jsonMapper.serialize(this.toClass(), options);
-  };
-
-  schema.loadClass(target);
-  core.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 = core.Store.from(target);
-
-  if (!store.has(MONGOOSE_SCHEMA)) {
-    createSchema(target, options);
-  }
-
-  return store.get(MONGOOSE_SCHEMA);
-}
-function getSchemaToken(target, options) {
-  const collectionName = options.name || core.nameOf(target);
-  const token = Symbol.for(changeCase.pascalCase(`${collectionName}Schema`));
-  return {
-    token,
-    collectionName
-  };
-}
-/**
- * @ignore
- */
-
-function buildMongooseSchema(target) {
-  const properties = schema.getProperties(target, {
-    withIgnoredProps: true,
-    mongoose: true,
-    groups: false
-  });
-  const schema$1 = {
-    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$1.virtuals.set(key, schemaTypeOptions);
-      return;
-    }
-
-    schema$1.schema[key] = createSchemaTypeOptions(propertyMetadata);
-  });
-  return schema$1;
-}
-/**
- * @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 = core.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. ${core.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);
-  core.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 = core.nameOf(target), collection, skipInit, connection, discriminatorValue) {
-  // if ancestor has a discriminatorKey we need to link model with anscestor schema
-  const ancestor = core.ancestorsOf(target).find(ancestor => {
-    const options = core.Store.from(ancestor).get(MONGOOSE_SCHEMA_OPTIONS) || {};
-    return !!options.discriminatorKey;
-  });
-
-  if (ancestor && ancestor !== target) {
-    const ancestorModel = core.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);
-    core.Store.from(target).set(MONGOOSE_MODEL, model);
-    return model;
-  }
-
-  const model = mongoose__default['default'].model(name, schema, collection, skipInit);
-  core.Store.from(target).set(MONGOOSE_MODEL, model);
-  return model;
-}
-
-function Schema(options = {}) {
-  return (...parameters) => {
-    switch (core.decoratorTypeOf(parameters)) {
-      case "property":
-        return core.useDecorators(schema.Property(), core.StoreMerge(MONGOOSE_SCHEMA, options))(parameters[0], parameters[1], parameters[2]);
-
-      case "class":
-        const {
-          token
-        } = getSchemaToken(parameters[0], options);
-        di.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 core.useDecorators(schema.Property(), SchemaIgnore(), (target, propertyKey) => {
-    core.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 core.useDecorators(schema.Property(String), schema.Example("5ce7ad3028890bd71749d477"), schema.Description("Mongoose Ref ObjectId"), core.StoreMerge(MONGOOSE_SCHEMA, {
-    type: mongoose.Schema.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);
-    di.registerProvider({
-      provide: token,
-      deps: [],
-
-      useFactory() {
-        return getSchema(target, options);
-      }
-
-    });
-    di.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
-      }]
-    });
-  };
-}
-
-exports.DecimalFormat = class DecimalFormat {
-  validate(num) {
-    return core.isString(num) || core.isNumber(num);
-  }
-
-};
-exports.DecimalFormat = tslib.__decorate([ajv.Formats("decimal", {
-  type: "number"
-})], exports.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$1 = {
-    type: mongoose.Schema.Types.Decimal128
-  };
-
-  if (type) {
-    // Define property getter to convert Decimal128 to custom type
-    schema$1.get = value => {
-      return isDecimal(value) ? new type(value) : value;
-    };
-  }
-
-  return core.useDecorators(schema.Property(Number), schema.Format("decimal"), schema.Example(12.34), core.StoreMerge(MONGOOSE_SCHEMA, schema$1), // Deserialize number value from JSON to Decimal128
-  jsonMapper.OnDeserialize(value => {
-    if (value === undefined) {
-      return undefined;
-    }
-
-    if (type) {
-      return new type(value);
-    }
-
-    if (core.isString(value)) {
-      return mongoose.Types.Decimal128.fromString(value);
-    }
-
-    return mongoose.Types.Decimal128.fromString(`${value}`);
-  }), // Serialize decimal value to floating point number
-  jsonMapper.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 core.useDecorators(name && schema.Name(name), schema.Pattern(/^[0-9a-fA-F]{24}$/), schema.Description("Mongoose ObjectId"), schema.Example("5ce7ad3028890bd71749d477"));
-}
-
-function PostHook(method, ...params) {
-  return (...args) => {
-    let options = params[1];
-    let fn = params[0];
-
-    if (core.decoratorTypeOf(args) === core.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 (core.decoratorTypeOf(args) === core.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 || core.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 = () => core.isString(model) ? MongooseModels.get(model) : core.isArrowFn(model) ? model() : model;
-
-  return core.useDecorators(schema.Property(Object), core.StoreMerge(MONGOOSE_SCHEMA, {
-    type: mongoose.Schema.Types[type],
-    ref: model
-  }), jsonMapper.OnDeserialize(value => {
-    if (isRef(value)) {
-      return value.toString();
-    }
-
-    return value;
-  }), jsonMapper.OnSerialize((value, ctx) => {
-    if (isRef(value)) {
-      return value.toString();
-    }
-
-    const type = getType();
-    return jsonMapper.serialize(value, _extends({}, ctx, {
-      type
-    }));
-  }), schema.JsonEntityFn(async store => {
-    store.itemSchema.oneOf([schema.string().example("5ce7ad3028890bd71749d477").description("Mongoose Ref ObjectId"), schema.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) => {
-    core.Store.from(target).merge(MONGOOSE_SCHEMA_OPTIONS, {
-      versionKey: propertyKey
-    });
-  };
-}
-
-function getRef(opts) {
-  const ref = opts.ref || opts.type;
-  return core.isString(ref) ? ref : core.Store.from(ref).get(MONGOOSE_MODEL_NAME);
-}
-
-function getType(opts) {
-  const ref = opts.ref || opts.type;
-  return !core.isString(ref) ? ref : Object;
-}
-
-function getInitialOpts(options, foreignField) {
-  return core.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$1 = mapToSchema(opts);
-  const type = getType(opts);
-  return core.useDecorators(core.StoreMerge(MONGOOSE_SCHEMA, schema$1), type && (schema$1.justOne ? schema.Property(type) : schema.CollectionOf(type)));
-}
-
-exports.Auto = Auto;
-exports.DiscriminatorKey = DiscriminatorKey;
-exports.DynamicRef = DynamicRef;
-exports.ExcludeIndexes = ExcludeIndexes;
-exports.Expires = Expires;
-exports.Immutable = Immutable;
-exports.Indexed = Indexed;
-exports.Lowercase = Lowercase;
-exports.MONGOOSE_MODEL = MONGOOSE_MODEL;
-exports.MONGOOSE_MODEL_NAME = MONGOOSE_MODEL_NAME;
-exports.MONGOOSE_SCHEMA = MONGOOSE_SCHEMA;
-exports.MONGOOSE_SCHEMA_OPTIONS = MONGOOSE_SCHEMA_OPTIONS;
-exports.Model = Model;
-exports.MongooseIndex = MongooseIndex;
-exports.MongoosePlugin = MongoosePlugin;
-exports.MongooseSchema = MongooseSchema;
-exports.NumberDecimal = NumberDecimal;
-exports.ObjectID = ObjectID;
-exports.PostHook = PostHook;
-exports.PreHook = PreHook;
-exports.Ref = Ref;
-exports.Schema = Schema;
-exports.SchemaIgnore = SchemaIgnore;
-exports.Select = Select;
-exports.Sparse = Sparse;
-exports.Text = Text;
-exports.Trim = Trim;
-exports.Unique = Unique;
-exports.Uppercase = Uppercase;
-exports.VersionKey = VersionKey;
-exports.VirtualRef = VirtualRef;
-exports.buildMongooseSchema = buildMongooseSchema;
-exports.createModel = createModel;
-exports.createSchema = createSchema;
-exports.createSchemaTypeOptions = createSchemaTypeOptions;
-exports.getModelToken = getModelToken;
-exports.getSchema = getSchema;
-exports.getSchemaToken = getSchemaToken;
-//# sourceMappingURL=index.js.map