@tsed/mongoose 6.69.1 → 6.69.2

package/lib/decorators/model.js

@@ -1,67 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Model = void 0;
-const di_1 = require("@tsed/di");
-const MongooseConnections_1 = require("../services/MongooseConnections");
-const utils_1 = require("../utils");
-const schemaOptions_1 = require("../utils/schemaOptions");
-/**
- * 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 } = utils_1.getModelToken(target, options);
-        di_1.registerProvider({
-            provide: token,
-            deps: [],
-            useFactory() {
-                return utils_1.getSchema(target, options);
-            }
-        });
-        di_1.registerProvider({
-            provide: target,
-            type: "mongoose:model",
-            deps: [MongooseConnections_1.MONGOOSE_CONNECTIONS, token],
-            useFactory(connections, schema) {
-                schemaOptions_1.applySchemaOptions(schema, schemaOptions_1.schemaOptions(target));
-                return utils_1.createModel(target, schema, collectionName, options.collection, options.skipInit, connections.get(options.connection), options.discriminatorValue);
-            }
-        });
-    };
-}
-exports.Model = Model;
-//# sourceMappingURL=model.js.map

package/lib/decorators/model.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"model.js","sourceRoot":"","sources":["../../src/decorators/model.ts"],"names":[],"mappings":";;;AACA,iCAA0C;AAI1C,yEAAqE;AACrE,oCAA+D;AAC/D,0DAAyE;AAEzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,SAAgB,KAAK,CAAC,UAAgC,EAAE;IACtD,OAAO,CAAC,MAAW,EAAE,EAAE;QACrB,MAAM,EAAC,KAAK,EAAE,cAAc,EAAC,GAAG,qBAAa,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAE/D,qBAAgB,CAAC;YACf,OAAO,EAAE,KAAK;YACd,IAAI,EAAE,EAAE;YACR,UAAU;gBACR,OAAO,iBAAS,CAAC,MAAM,EAAE,OAAc,CAAC,CAAC;YAC3C,CAAC;SACF,CAAC,CAAC;QAEH,qBAAgB,CAAC;YACf,OAAO,EAAE,MAAM;YACf,IAAI,EAAE,gBAAgB;YACtB,IAAI,EAAE,CAAC,0CAAoB,EAAE,KAAK,CAAC;YACnC,UAAU,CAAC,WAAiC,EAAE,MAAc;gBAC1D,kCAAkB,CAAC,MAAM,EAAE,6BAAa,CAAC,MAAM,CAAC,CAAC,CAAC;gBAClD,OAAO,mBAAW,CAChB,MAAM,EACN,MAAM,EACN,cAAc,EACd,OAAO,CAAC,UAAU,EAClB,OAAO,CAAC,QAAQ,EAChB,WAAW,CAAC,GAAG,CAAC,OAAO,CAAC,UAAU,CAAC,EACnC,OAAO,CAAC,kBAAkB,CAC3B,CAAC;YACJ,CAAC;SACF,CAAC,CAAC;IACL,CAAC,CAAC;AACJ,CAAC;AA9BD,sBA8BC","sourcesContent":["import {Store} from \"@tsed/core\";\nimport {registerProvider} from \"@tsed/di\";\nimport {Schema} from \"mongoose\";\nimport {MONGOOSE_MODEL} from \"../constants\";\nimport {MongooseModelOptions} from \"../interfaces/MongooseModelOptions\";\nimport {MONGOOSE_CONNECTIONS} from \"../services/MongooseConnections\";\nimport {createModel, getModelToken, getSchema} from \"../utils\";\nimport {applySchemaOptions, schemaOptions} from \"../utils/schemaOptions\";\n\n/**\n * Define a class as a Mongoose Model. The model can be injected to the Service, Controller, Middleware, Converters or Filter with\n * `@Inject` annotation.\n *\n * ### Example\n *\n * ```typescript\n * @Model()\n * export class EventModel {\n *   @Property()\n *   field: string;\n * }\n * ```\n *\n * Then inject the model into a service:\n *\n * ```typescript\n * class MyService {\n *    constructor(@Inject(EventModel) eventModel: MongooseModel<EventModel>) {\n *        eventModel.findById().exec();\n *    }\n * }\n * ```\n *\n * ### Options\n *\n * - `schemaOptions` (mongoose.SchemaOptions): Option to configure the schema behavior.\n * - `name` (String): model name.\n * - `collection` (String): collection (optional, induced from model name).\n * - `skipInit` (Boolean): skipInit whether to skip initialization (defaults to false).\n *\n * @param {MongooseModelOptions} options\n * @returns {(target: any) => void}\n * @decorator\n * @mongoose\n * @class\n */\nexport function Model(options: MongooseModelOptions = {}) {\n  return (target: any) => {\n    const {token, collectionName} = getModelToken(target, options);\n\n    registerProvider({\n      provide: token,\n      deps: [],\n      useFactory() {\n        return getSchema(target, options as any);\n      }\n    });\n\n    registerProvider({\n      provide: target,\n      type: \"mongoose:model\",\n      deps: [MONGOOSE_CONNECTIONS, token],\n      useFactory(connections: MONGOOSE_CONNECTIONS, schema: Schema) {\n        applySchemaOptions(schema, schemaOptions(target));\n        return createModel(\n          target,\n          schema,\n          collectionName,\n          options.collection,\n          options.skipInit,\n          connections.get(options.connection),\n          options.discriminatorValue\n        );\n      }\n    });\n  };\n}\n"]}

package/lib/decorators/mongooseIndex.js

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MongooseIndex = void 0;
-const schemaOptions_1 = require("../utils/schemaOptions");
-/**
- * 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_1.schemaOptions(target, {
-            indexes: [{ fields, options }]
-        });
-    };
-}
-exports.MongooseIndex = MongooseIndex;
-//# sourceMappingURL=mongooseIndex.js.map

package/lib/decorators/mongooseIndex.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"mongooseIndex.js","sourceRoot":"","sources":["../../src/decorators/mongooseIndex.ts"],"names":[],"mappings":";;;AAAA,0DAAqD;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,SAAgB,aAAa,CAAC,MAAc,EAAE,OAAa;IACzD,OAAO,CAAC,MAAW,EAAE,EAAE;QACrB,6BAAa,CAAC,MAAM,EAAE;YACpB,OAAO,EAAE,CAAC,EAAC,MAAM,EAAE,OAAO,EAAC,CAAC;SAC7B,CAAC,CAAC;IACL,CAAC,CAAC;AACJ,CAAC;AAND,sCAMC","sourcesContent":["import {schemaOptions} from \"../utils/schemaOptions\";\n\n/**\n * Calls schema.index() to define an index (most likely compound) for the schema.\n *\n * ### Example\n *\n * ```typescript\n * @Model()\n * @MongooseIndex({first: 1, second: 1}, {unique: 1})\n * export class EventModel {\n *\n *   @Property()\n *   first: string;\n *\n *   @Property()\n *   second: string;\n *\n * }\n * ```\n *\n * @param fields\n * @param options\n * @returns {Function}\n * @decorator\n * @mongoose\n * @class\n */\nexport function MongooseIndex(fields: object, options?: any): Function {\n  return (target: any) => {\n    schemaOptions(target, {\n      indexes: [{fields, options}]\n    });\n  };\n}\n"]}

package/lib/decorators/mongooseIndexes.d.ts

@@ -1,32 +0,0 @@
-/**
- * Calls schema.index() to define multiple indexes (most likely compound) for the schema.
- *
- * ### Example
- *
- * ```typescript
- * @Model()
- * @MongooseIndexes([{fields: {first: 1, second: 1}, options:{unique: 1}}, {fields: {first: 1, third: 1}, options:{unique: 1}}])
- * export class EventModel {
- *
- *   @Property()
- *   first: string;
- *
- *   @Property()
- *   second: string;
- *
- *   @Property()
- *   third: string;
- *
- * }
- * ```
- *
- * @param indexes - define multiple mongoose indexes
- * @returns {Function}
- * @decorator
- * @mongoose
- * @class
- */
-export declare function MongooseIndexes(indexes: Array<{
-    fields: object;
-    options?: any;
-}>): Function;

package/lib/decorators/mongooseIndexes.js

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MongooseIndexes = void 0;
-const schemaOptions_1 = require("../utils/schemaOptions");
-/**
- * Calls schema.index() to define multiple indexes (most likely compound) for the schema.
- *
- * ### Example
- *
- * ```typescript
- * @Model()
- * @MongooseIndexes([{fields: {first: 1, second: 1}, options:{unique: 1}}, {fields: {first: 1, third: 1}, options:{unique: 1}}])
- * export class EventModel {
- *
- *   @Property()
- *   first: string;
- *
- *   @Property()
- *   second: string;
- *
- *   @Property()
- *   third: string;
- *
- * }
- * ```
- *
- * @param indexes - define multiple mongoose indexes
- * @returns {Function}
- * @decorator
- * @mongoose
- * @class
- */
-function MongooseIndexes(indexes) {
-    return (target) => {
-        schemaOptions_1.schemaOptions(target, { indexes });
-    };
-}
-exports.MongooseIndexes = MongooseIndexes;
-//# sourceMappingURL=mongooseIndexes.js.map

package/lib/decorators/mongooseIndexes.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"mongooseIndexes.js","sourceRoot":"","sources":["../../src/decorators/mongooseIndexes.ts"],"names":[],"mappings":";;;AAAA,0DAAqD;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,SAAgB,eAAe,CAAC,OAA+C;IAC7E,OAAO,CAAC,MAAW,EAAE,EAAE;QACrB,6BAAa,CAAC,MAAM,EAAE,EAAC,OAAO,EAAC,CAAC,CAAC;IACnC,CAAC,CAAC;AACJ,CAAC;AAJD,0CAIC","sourcesContent":["import {schemaOptions} from \"../utils/schemaOptions\";\n\n/**\n * Calls schema.index() to define multiple indexes (most likely compound) for the schema.\n *\n * ### Example\n *\n * ```typescript\n * @Model()\n * @MongooseIndexes([{fields: {first: 1, second: 1}, options:{unique: 1}}, {fields: {first: 1, third: 1}, options:{unique: 1}}])\n * export class EventModel {\n *\n *   @Property()\n *   first: string;\n *\n *   @Property()\n *   second: string;\n *\n *   @Property()\n *   third: string;\n *\n * }\n * ```\n *\n * @param indexes - define multiple mongoose indexes\n * @returns {Function}\n * @decorator\n * @mongoose\n * @class\n */\nexport function MongooseIndexes(indexes: Array<{fields: object; options?: any}>): Function {\n  return (target: any) => {\n    schemaOptions(target, {indexes});\n  };\n}\n"]}

package/lib/decorators/mongoosePlugin.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MongoosePlugin = void 0;
-const schemaOptions_1 = require("../utils/schemaOptions");
-/**
- *
- * @param {(schema: "mongoose".Schema, options?: any) => void} plugin
- * @param options
- * @returns {Function}
- * @decorator
- * @mongoose
- * @class
- */
-function MongoosePlugin(plugin, options) {
-    return (target) => {
-        schemaOptions_1.schemaOptions(target, {
-            plugins: [{ plugin, options }]
-        });
-    };
-}
-exports.MongoosePlugin = MongoosePlugin;
-//# sourceMappingURL=mongoosePlugin.js.map

package/lib/decorators/mongoosePlugin.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"mongoosePlugin.js","sourceRoot":"","sources":["../../src/decorators/mongoosePlugin.ts"],"names":[],"mappings":";;;AACA,0DAAqD;AAErD;;;;;;;;GAQG;AACH,SAAgB,cAAc,CAAC,MAAwD,EAAE,OAAa;IACpG,OAAO,CAAC,MAAW,EAAE,EAAE;QACrB,6BAAa,CAAC,MAAM,EAAE;YACpB,OAAO,EAAE,CAAC,EAAC,MAAM,EAAE,OAAO,EAAC,CAAC;SAC7B,CAAC,CAAC;IACL,CAAC,CAAC;AACJ,CAAC;AAND,wCAMC","sourcesContent":["import mongoose from \"mongoose\";\nimport {schemaOptions} from \"../utils/schemaOptions\";\n\n/**\n *\n * @param {(schema: \"mongoose\".Schema, options?: any) => void} plugin\n * @param options\n * @returns {Function}\n * @decorator\n * @mongoose\n * @class\n */\nexport function MongoosePlugin(plugin: (schema: mongoose.Schema, options?: any) => void, options?: any): Function {\n  return (target: any) => {\n    schemaOptions(target, {\n      plugins: [{plugin, options}]\n    });\n  };\n}\n"]}

package/lib/decorators/numberDecimal.js

@@ -1,75 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NumberDecimal = exports.DecimalFormat = void 0;
-const tslib_1 = require("tslib");
-const ajv_1 = require("@tsed/ajv");
-const core_1 = require("@tsed/core");
-const json_mapper_1 = require("@tsed/json-mapper");
-const schema_1 = require("@tsed/schema");
-const mongoose_1 = require("mongoose");
-const constants_1 = require("../constants");
-let DecimalFormat = class DecimalFormat {
-    validate(num) {
-        return core_1.isString(num) || core_1.isNumber(num);
-    }
-};
-DecimalFormat = tslib_1.__decorate([
-    ajv_1.Formats("decimal", { type: "number" })
-], DecimalFormat);
-exports.DecimalFormat = 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: mongoose_1.Schema.Types.Decimal128
-    };
-    if (type) {
-        // Define property getter to convert Decimal128 to custom type
-        schema.get = (value) => {
-            return isDecimal(value) ? new type(value) : value;
-        };
-    }
-    return core_1.useDecorators(schema_1.Property(Number), schema_1.Format("decimal"), schema_1.Example(12.34), core_1.StoreMerge(constants_1.MONGOOSE_SCHEMA, schema), 
-    // Deserialize number value from JSON to Decimal128
-    json_mapper_1.OnDeserialize((value) => {
-        if (type) {
-            return new type(value);
-        }
-        if (core_1.isString(value)) {
-            return mongoose_1.Types.Decimal128.fromString(value);
-        }
-        return mongoose_1.Types.Decimal128.fromString(`${value}`);
-    }), 
-    // Serialize decimal value to floating point number
-    json_mapper_1.OnSerialize((value, ctx) => {
-        return value && Number(value);
-    }));
-}
-exports.NumberDecimal = NumberDecimal;
-//# sourceMappingURL=numberDecimal.js.map

package/lib/decorators/numberDecimal.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"numberDecimal.js","sourceRoot":"","sources":["../../src/decorators/numberDecimal.ts"],"names":[],"mappings":";;;;AAAA,mCAAkD;AAClD,qCAAyE;AACzE,mDAA6D;AAC7D,yCAAuD;AACvD,uCAA4E;AAC5E,4CAA6C;AAG7C,IAAa,aAAa,GAA1B,MAAa,aAAa;IACxB,QAAQ,CAAC,GAAoB;QAC3B,OAAO,eAAQ,CAAC,GAAG,CAAC,IAAI,eAAQ,CAAC,GAAG,CAAC,CAAC;IACxC,CAAC;CACF,CAAA;AAJY,aAAa;IADzB,aAAO,CAAC,SAAS,EAAE,EAAC,IAAI,EAAE,QAAQ,EAAC,CAAC;GACxB,aAAa,CAIzB;AAJY,sCAAa;AAM1B,SAAS,SAAS,CAAC,KAA+B;IAChD,OAAO,KAAK,IAAI,KAAK,CAAC,SAAS,KAAK,YAAY,CAAC;AACnD,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,SAAgB,aAAa,CAAC,IAAU;IACtC,MAAM,MAAM,GAAkC;QAC5C,IAAI,EAAE,iBAAc,CAAC,KAAK,CAAC,UAAU;KACtC,CAAC;IAEF,IAAI,IAAI,EAAE;QACR,8DAA8D;QAC9D,MAAM,CAAC,GAAG,GAAG,CAAC,KAAK,EAAE,EAAE;YACrB,OAAO,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;QACpD,CAAC,CAAC;KACH;IAED,OAAO,oBAAa,CAClB,iBAAQ,CAAC,MAAM,CAAC,EAChB,eAAM,CAAC,SAAS,CAAC,EACjB,gBAAO,CAAC,KAAK,CAAC,EACd,iBAAU,CAAC,2BAAe,EAAE,MAAM,CAAC;IAEnC,mDAAmD;IACnD,2BAAa,CAAC,CAAC,KAAK,EAAE,EAAE;QACtB,IAAI,IAAI,EAAE;YACR,OAAO,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC;SACxB;QACD,IAAI,eAAQ,CAAC,KAAK,CAAC,EAAE;YACnB,OAAO,gBAAK,CAAC,UAAU,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;SAC3C;QACD,OAAO,gBAAK,CAAC,UAAU,CAAC,UAAU,CAAC,GAAG,KAAK,EAAE,CAAC,CAAC;IACjD,CAAC,CAAC;IAEF,mDAAmD;IACnD,yBAAW,CAAC,CAAC,KAAU,EAAE,GAAG,EAAE,EAAE;QAC9B,OAAO,KAAK,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC;IAChC,CAAC,CAAC,CACH,CAAC;AACJ,CAAC;AAlCD,sCAkCC","sourcesContent":["import {Formats, FormatsMethods} from \"@tsed/ajv\";\nimport {isNumber, isString, StoreMerge, useDecorators} from \"@tsed/core\";\nimport {OnDeserialize, OnSerialize} from \"@tsed/json-mapper\";\nimport {Example, Format, Property} from \"@tsed/schema\";\nimport {Types, Schema as MongooseSchema, SchemaTypeOptions} from \"mongoose\";\nimport {MONGOOSE_SCHEMA} from \"../constants\";\n\n@Formats(\"decimal\", {type: \"number\"})\nexport class DecimalFormat implements FormatsMethods<string | number> {\n  validate(num: string | number): boolean {\n    return isString(num) || isNumber(num);\n  }\n}\n\nfunction isDecimal(value: undefined | number | any) {\n  return value && value._bsontype === \"Decimal128\";\n}\n\n/**\n * Tell Mongoose whether to define an Decimal128 property.\n * Will be serialized as `number` with format as `decimal`.\n * ### Example\n *\n * ```typescript\n * @Model()\n * export class PriceModel {\n *   @NumberDecimal()\n *   price: Decimal128;\n * }\n * ```\n * Optionally using custom decimal type, such as `Big` from big.js\n * ```typescript\n * @Model()\n * export class PriceModel {\n *   @NumberDecimal(Big)\n *   price: Big;\n * }\n * ```\n * @param type Optional decimal type constructor\n * @decorator\n * @mongoose\n * @schema\n */\nexport function NumberDecimal(type?: any) {\n  const schema: SchemaTypeOptions<Decimal128> = {\n    type: MongooseSchema.Types.Decimal128\n  };\n\n  if (type) {\n    // Define property getter to convert Decimal128 to custom type\n    schema.get = (value) => {\n      return isDecimal(value) ? new type(value) : value;\n    };\n  }\n\n  return useDecorators(\n    Property(Number),\n    Format(\"decimal\"),\n    Example(12.34),\n    StoreMerge(MONGOOSE_SCHEMA, schema),\n\n    // Deserialize number value from JSON to Decimal128\n    OnDeserialize((value) => {\n      if (type) {\n        return new type(value);\n      }\n      if (isString(value)) {\n        return Types.Decimal128.fromString(value);\n      }\n      return Types.Decimal128.fromString(`${value}`);\n    }),\n\n    // Serialize decimal value to floating point number\n    OnSerialize((value: any, ctx) => {\n      return value && Number(value);\n    })\n  );\n}\n\nexport type Decimal128 = Types.Decimal128;\n"]}

package/lib/decorators/objectID.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ObjectID = void 0;
-const core_1 = require("@tsed/core");
-const schema_1 = require("@tsed/schema");
-/**
- * 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_1.useDecorators(name && schema_1.Name(name), schema_1.Pattern(/^[0-9a-fA-F]{24}$/), schema_1.Description("Mongoose ObjectId"), schema_1.Example("5ce7ad3028890bd71749d477"));
-}
-exports.ObjectID = ObjectID;
-//# sourceMappingURL=objectID.js.map

package/lib/decorators/objectID.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"objectID.js","sourceRoot":"","sources":["../../src/decorators/objectID.ts"],"names":[],"mappings":";;;AAAA,qCAAyC;AACzC,yCAAiE;AAGjE;;;;;;;;;;;;;;;GAeG;AACH,SAAgB,QAAQ,CAAC,IAAa;IACpC,OAAO,oBAAa,CAClB,IAAI,IAAI,aAAI,CAAC,IAAI,CAAC,EAClB,gBAAO,CAAC,mBAAmB,CAAC,EAC5B,oBAAW,CAAC,mBAAmB,CAAC,EAChC,gBAAO,CAAC,0BAA0B,CAAC,CACpC,CAAC;AACJ,CAAC;AAPD,4BAOC","sourcesContent":["import {useDecorators} from \"@tsed/core\";\nimport {Description, Example, Name, Pattern} from \"@tsed/schema\";\nimport {Types} from \"mongoose\";\n\n/**\n * Tell Mongoose whether to define an ObjectId property.\n * ### Example\n *\n * ```typescript\n * @Model()\n * export class EventModel {\n *   @ObjectId('id')\n *   _id: string;\n * }\n * ```\n * @param name\n * @decorator\n * @mongoose\n * @schema\n */\nexport function ObjectID(name?: string) {\n  return useDecorators(\n    name && Name(name),\n    Pattern(/^[0-9a-fA-F]{24}$/),\n    Description(\"Mongoose ObjectId\"),\n    Example(\"5ce7ad3028890bd71749d477\")\n  );\n}\n\nexport type ObjectID = Types.ObjectId;\n"]}

package/lib/decorators/postHook.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PostHook = void 0;
-const core_1 = require("@tsed/core");
-const schemaOptions_1 = require("../utils/schemaOptions");
-function PostHook(method, ...params) {
-    return ((...args) => {
-        let options = params[1];
-        let fn = params[0];
-        if (core_1.decoratorTypeOf(args) === core_1.DecoratorTypes.METHOD_STC) {
-            options = params[0];
-            fn = args[0][args[1]].bind(args[0]);
-        }
-        schemaOptions_1.schemaOptions(args[0], {
-            post: [
-                {
-                    method,
-                    fn,
-                    options
-                }
-            ]
-        });
-    });
-}
-exports.PostHook = PostHook;
-//# sourceMappingURL=postHook.js.map

package/lib/decorators/postHook.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"postHook.js","sourceRoot":"","sources":["../../src/decorators/postHook.ts"],"names":[],"mappings":";;;AAAA,qCAAkF;AAElF,0DAAqD;AAgDrD,SAAgB,QAAQ,CAAU,MAAc,EAAE,GAAG,MAAa;IAChE,OAAO,CAAC,CAAC,GAAG,IAAW,EAAE,EAAE;QACzB,IAAI,OAAO,GAAwB,MAAM,CAAC,CAAC,CAAC,CAAC;QAC7C,IAAI,EAAE,GAA0B,MAAM,CAAC,CAAC,CAAC,CAAC;QAE1C,IAAI,sBAAe,CAAC,IAAI,CAAC,KAAK,qBAAc,CAAC,UAAU,EAAE;YACvD,OAAO,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;YACpB,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;SACrC;QAED,6BAAa,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE;YACrB,IAAI,EAAE;gBACJ;oBACE,MAAM;oBACN,EAAE;oBACF,OAAO;iBACR;aACF;SACF,CAAC,CAAC;IACL,CAAC,CAAQ,CAAC;AACZ,CAAC;AApBD,4BAoBC","sourcesContent":["import {decoratorTypeOf, DecoratorTypes, StaticMethodDecorator} from \"@tsed/core\";\nimport {MongooseHookOptions, MongoosePostHookCB} from \"../interfaces\";\nimport {schemaOptions} from \"../utils/schemaOptions\";\n\n/**\n * We can simply attach a `@PostHook` decorator to your model class and\n * define the hook function like you normally would in Mongoose.\n *\n * ```typescript\n * import {Ignore, Required} from \"@tsed/common\";\n * import {PostHook, Model} from \"@tsed/mongoose\";\n *\n * @Model()\n * @PostHook(\"save\", (car: CarModel) => {\n *    if (car.topSpeedInKmH > 300) {\n *        console.log(car.model, 'is fast!');\n *    }\n * })\n * export class CarModel {\n *    @Ignore()\n *    _id: string;\n *\n *    @Required()\n *    model: string;\n *\n *    @Required()\n *    isFast: boolean;\n *\n *    // or Prehook on static method\n *    @PostHook(\"save\")\n *    static postSave(car: CarModel) {\n *       if (car.topSpeedInKmH > 300) {\n *           console.log(car.model, 'is fast!');\n *       }\n *    }\n * }\n * ```\n *\n * This will execute the post-save hook each time a `CarModel` document is saved.\n *\n * @param {string} method\n * @param fn\n * @returns {Function}\n * @decorator\n * @mongoose\n * @class\n */\nexport function PostHook<T = any>(method: string, fn: MongoosePostHookCB<T>): ClassDecorator;\nexport function PostHook<T = any>(method: string, fn: MongoosePostHookCB<T>, options: MongooseHookOptions): ClassDecorator;\nexport function PostHook<T = any>(method: string, options: MongooseHookOptions): StaticMethodDecorator;\nexport function PostHook<T = any>(method: string, ...params: any[]): Function {\n  return ((...args: any[]) => {\n    let options: MongooseHookOptions = params[1];\n    let fn: MongoosePostHookCB<T> = params[0];\n\n    if (decoratorTypeOf(args) === DecoratorTypes.METHOD_STC) {\n      options = params[0];\n      fn = args[0][args[1]].bind(args[0]);\n    }\n\n    schemaOptions(args[0], {\n      post: [\n        {\n          method,\n          fn,\n          options\n        }\n      ]\n    });\n  }) as any;\n}\n"]}

package/lib/decorators/preHook.js

@@ -1,71 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PreHook = void 0;
-const core_1 = require("@tsed/core");
-const schemaOptions_1 = require("../utils/schemaOptions");
-/**
- *
- * 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_1.decoratorTypeOf(args) === core_1.DecoratorTypes.METHOD_STC) {
-            options = fn;
-            fn = args[0][args[1]].bind(args[0]);
-        }
-        schemaOptions_1.schemaOptions(args[0], {
-            pre: [
-                {
-                    method,
-                    fn: fn,
-                    options
-                }
-            ]
-        });
-    };
-}
-exports.PreHook = PreHook;
-//# sourceMappingURL=preHook.js.map

package/lib/decorators/preHook.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"preHook.js","sourceRoot":"","sources":["../../src/decorators/preHook.ts"],"names":[],"mappings":";;;AAAA,qCAA2D;AAE3D,0DAAqD;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,SAAgB,OAAO,CAAU,MAAc,EAAE,EAA+C,EAAE,OAA6B;IAC7H,OAAO,CAAC,GAAG,IAAW,EAAE,EAAE;QACxB,IAAI,sBAAe,CAAC,IAAI,CAAC,KAAK,qBAAc,CAAC,UAAU,EAAE;YACvD,OAAO,GAAG,EAAyB,CAAC;YACpC,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;SACrC;QAED,6BAAa,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE;YACrB,GAAG,EAAE;gBACH;oBACE,MAAM;oBACN,EAAE,EAAE,EAA0B;oBAC9B,OAAO;iBACR;aACF;SACF,CAAC,CAAC;IACL,CAAC,CAAC;AACJ,CAAC;AAjBD,0BAiBC","sourcesContent":["import {decoratorTypeOf, DecoratorTypes} from \"@tsed/core\";\nimport {MongooseHookOptions, MongoosePreHookCB} from \"../interfaces\";\nimport {schemaOptions} from \"../utils/schemaOptions\";\n\n/**\n *\n * We can simply attach a `@PreHook` decorator to your model class and\n * define the hook function like you normally would in Mongoose.\n *\n * ```typescript\n * import {Ignore, Required} from \"@tsed/common\";\n * import {PreHook, Model} from \"@tsed/mongoose\";\n *\n * @Model()\n * @PreHook(\"save\", (car: CarModel, next) => {\n *    if (car.model === 'Tesla') {\n *        car.isFast = true;\n *      }\n *      next();\n *})\n * export class CarModel {\n *\n *    @Ignore()\n *    _id: string;\n *\n *    @Required()\n *    model: string;\n *\n *    @Required()\n *    isFast: boolean;\n *\n *    // or Prehook on static method\n *    @PreHook(\"save\")\n *    static preSave(car: CarModel, next) {\n *       if (car.model === 'Tesla') {\n *           car.isFast = true;\n *       }\n *       next();\n *    }\n * }\n * ```\n *\n * This will execute the pre-save hook each time a `CarModel` document is saved.\n *\n * @param {string} method\n * @param fn\n * @param options\n * @returns {Function}\n * @decorator\n * @class\n */\nexport function PreHook<T = any>(method: string, fn?: MongoosePreHookCB<T> | MongooseHookOptions, options?: MongooseHookOptions): Function {\n  return (...args: any[]) => {\n    if (decoratorTypeOf(args) === DecoratorTypes.METHOD_STC) {\n      options = fn as MongooseHookOptions;\n      fn = args[0][args[1]].bind(args[0]);\n    }\n\n    schemaOptions(args[0], {\n      pre: [\n        {\n          method,\n          fn: fn as MongoosePreHookCB<T>,\n          options\n        }\n      ]\n    });\n  };\n}\n"]}

package/lib/decorators/ref.js

@@ -1,65 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Ref = void 0;
-const core_1 = require("@tsed/core");
-const json_mapper_1 = require("@tsed/json-mapper");
-const schema_1 = require("@tsed/schema");
-const mongoose_1 = require("mongoose");
-const constants_1 = require("../constants");
-const MongooseSchemaTypes_1 = require("../interfaces/MongooseSchemaTypes");
-const MongooseModels_1 = require("../registries/MongooseModels");
-function isRef(value) {
-    return (value && value._bsontype) || core_1.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_1.MongooseSchemaTypes.OBJECT_ID) {
-    const getType = () => (core_1.isString(model) ? MongooseModels_1.MongooseModels.get(model) : core_1.isArrowFn(model) ? model() : model);
-    return core_1.useDecorators(schema_1.Property(Object), core_1.StoreMerge(constants_1.MONGOOSE_SCHEMA, {
-        type: mongoose_1.Schema.Types[type],
-        ref: model
-    }), json_mapper_1.OnDeserialize((value) => {
-        if (isRef(value)) {
-            return value.toString();
-        }
-        return value;
-    }), json_mapper_1.OnSerialize((value, ctx) => {
-        if (isRef(value)) {
-            return value.toString();
-        }
-        const type = getType();
-        return json_mapper_1.serialize(value, { ...ctx, type });
-    }), schema_1.JsonEntityFn(async (store) => {
-        store.itemSchema.oneOf([schema_1.string().example("5ce7ad3028890bd71749d477").description("Mongoose Ref ObjectId"), schema_1.lazyRef(getType)]);
-        store.type = Object;
-    }));
-}
-exports.Ref = Ref;
-//# sourceMappingURL=ref.js.map

package/lib/decorators/ref.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ref.js","sourceRoot":"","sources":["../../src/decorators/ref.ts"],"names":[],"mappings":";;;AAAA,qCAAgF;AAChF,mDAAwE;AACxE,yCAAqE;AACrE,uCAAkD;AAClD,4CAA6C;AAC7C,2EAAsE;AACtE,iEAA4D;AAE5D,SAAS,KAAK,CAAC,KAA+B;IAC5C,OAAO,CAAC,KAAK,IAAI,KAAK,CAAC,SAAS,CAAC,IAAI,eAAQ,CAAC,KAAK,CAAC,CAAC;AACvD,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,SAAgB,GAAG,CAAC,KAAkC,EAAE,OAA4B,yCAAmB,CAAC,SAAS;IAC/G,MAAM,OAAO,GAAG,GAAG,EAAE,CAAC,CAAC,eAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,+BAAc,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,gBAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;IAEzG,OAAO,oBAAa,CAClB,iBAAQ,CAAC,MAAM,CAAC,EAChB,iBAAU,CAAC,2BAAe,EAAE;QAC1B,IAAI,EAAE,iBAAc,CAAC,KAAK,CAAC,IAAI,CAAC;QAChC,GAAG,EAAE,KAAK;KACX,CAAC,EACF,2BAAa,CAAC,CAAC,KAAK,EAAE,EAAE;QACtB,IAAI,KAAK,CAAC,KAAK,CAAC,EAAE;YAChB,OAAO,KAAK,CAAC,QAAQ,EAAE,CAAC;SACzB;QAED,OAAO,KAAK,CAAC;IACf,CAAC,CAAC,EACF,yBAAW,CAAC,CAAC,KAAU,EAAE,GAAG,EAAE,EAAE;QAC9B,IAAI,KAAK,CAAC,KAAK,CAAC,EAAE;YAChB,OAAO,KAAK,CAAC,QAAQ,EAAE,CAAC;SACzB;QACD,MAAM,IAAI,GAAG,OAAO,EAAE,CAAC;QAEvB,OAAO,uBAAS,CAAC,KAAK,EAAE,EAAC,GAAG,GAAG,EAAE,IAAI,EAAC,CAAC,CAAC;IAC1C,CAAC,CAAC,EACF,qBAAY,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE;QAC3B,KAAK,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,eAAM,EAAE,CAAC,OAAO,CAAC,0BAA0B,CAAC,CAAC,WAAW,CAAC,uBAAuB,CAAC,EAAE,gBAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;QAE9H,KAAK,CAAC,IAAI,GAAG,MAAM,CAAC;IACtB,CAAC,CAAC,CACkB,CAAC;AACzB,CAAC;AA9BD,kBA8BC","sourcesContent":["import {isArrowFn, isString, StoreMerge, Type, useDecorators} from \"@tsed/core\";\nimport {OnDeserialize, OnSerialize, serialize} from \"@tsed/json-mapper\";\nimport {JsonEntityFn, lazyRef, Property, string} from \"@tsed/schema\";\nimport {Schema as MongooseSchema} from \"mongoose\";\nimport {MONGOOSE_SCHEMA} from \"../constants\";\nimport {MongooseSchemaTypes} from \"../interfaces/MongooseSchemaTypes\";\nimport {MongooseModels} from \"../registries/MongooseModels\";\n\nfunction isRef(value: undefined | string | any) {\n  return (value && value._bsontype) || isString(value);\n}\n\n/**\n * Define a property as mongoose reference to other Model (decorated with @Model).\n *\n * ### Example\n *\n * ```typescript\n *\n * @Model()\n * class FooModel {\n *\n *    @Ref(Foo2Model)\n *    field: Ref<Foo2Model>\n *\n *    @Ref(Foo2Model)\n *    list: Ref<Foo2Model>[]\n * }\n *\n * @Model()\n * class Foo2Model {\n * }\n * ```\n *\n * @param model\n * @param type\n * @returns {Function}\n * @decorator\n * @mongoose\n * @property\n */\nexport function Ref(model: string | (() => Type) | any, type: MongooseSchemaTypes = MongooseSchemaTypes.OBJECT_ID): PropertyDecorator {\n  const getType = () => (isString(model) ? MongooseModels.get(model) : isArrowFn(model) ? model() : model);\n\n  return useDecorators(\n    Property(Object),\n    StoreMerge(MONGOOSE_SCHEMA, {\n      type: MongooseSchema.Types[type],\n      ref: model\n    }),\n    OnDeserialize((value) => {\n      if (isRef(value)) {\n        return value.toString();\n      }\n\n      return value;\n    }),\n    OnSerialize((value: any, ctx) => {\n      if (isRef(value)) {\n        return value.toString();\n      }\n      const type = getType();\n\n      return serialize(value, {...ctx, type});\n    }),\n    JsonEntityFn(async (store) => {\n      store.itemSchema.oneOf([string().example(\"5ce7ad3028890bd71749d477\").description(\"Mongoose Ref ObjectId\"), lazyRef(getType)]);\n\n      store.type = Object;\n    })\n  ) as PropertyDecorator;\n}\n\nexport type Ref<T> = T | string;\n"]}

package/lib/decorators/schema.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MongooseSchema = exports.Schema = void 0;
-const core_1 = require("@tsed/core");
-const di_1 = require("@tsed/di");
-const schema_1 = require("@tsed/schema");
-const constants_1 = require("../constants");
-const createSchema_1 = require("../utils/createSchema");
-function Schema(options = {}) {
-    return (...parameters) => {
-        switch (core_1.decoratorTypeOf(parameters)) {
-            case "property":
-                return core_1.useDecorators(schema_1.Property(), core_1.StoreMerge(constants_1.MONGOOSE_SCHEMA, options))(parameters[0], parameters[1], parameters[2]);
-            case "class":
-                const { token } = createSchema_1.getSchemaToken(parameters[0], options);
-                di_1.registerProvider({
-                    provide: token,
-                    deps: [],
-                    useFactory() {
-                        return createSchema_1.getSchema(parameters[0], options);
-                    }
-                });
-                break;
-        }
-    };
-}
-exports.Schema = Schema;
-function MongooseSchema(options = {}) {
-    return Schema(options);
-}
-exports.MongooseSchema = MongooseSchema;
-//# sourceMappingURL=schema.js.map

package/lib/decorators/schema.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/decorators/schema.ts"],"names":[],"mappings":";;;AAAA,qCAAsE;AACtE,iCAA0C;AAC1C,yCAAsC;AAEtC,4CAA6C;AAE7C,wDAAgE;AA4BhE,SAAgB,MAAM,CAAC,UAA0D,EAAE;IACjF,OAAO,CAAC,GAAG,UAAiB,EAAE,EAAE;QAC9B,QAAQ,sBAAe,CAAC,UAAU,CAAC,EAAE;YACnC,KAAK,UAAU;gBACb,OAAO,oBAAa,CAAC,iBAAQ,EAAE,EAAE,iBAAU,CAAC,2BAAe,EAAE,OAAO,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;YAEtH,KAAK,OAAO;gBACV,MAAM,EAAC,KAAK,EAAC,GAAG,6BAAc,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;gBAEvD,qBAAgB,CAAC;oBACf,OAAO,EAAE,KAAK;oBACd,IAAI,EAAE,EAAE;oBACR,UAAU;wBACR,OAAO,wBAAS,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,OAAc,CAAC,CAAC;oBAClD,CAAC;iBACF,CAAC,CAAC;gBACH,MAAM;SACT;IACH,CAAC,CAAC;AACJ,CAAC;AAnBD,wBAmBC;AA4BD,SAAgB,cAAc,CAAC,UAA0D,EAAE;IACzF,OAAO,MAAM,CAAC,OAAc,CAAC,CAAC;AAChC,CAAC;AAFD,wCAEC","sourcesContent":["import {decoratorTypeOf, StoreMerge, useDecorators} from \"@tsed/core\";\nimport {registerProvider} from \"@tsed/di\";\nimport {Property} from \"@tsed/schema\";\nimport {SchemaTypeOptions} from \"mongoose\";\nimport {MONGOOSE_SCHEMA} from \"../constants\";\nimport {MongooseSchemaOptions} from \"../interfaces\";\nimport {getSchema, getSchemaToken} from \"../utils/createSchema\";\n\n/**\n * Define a class as a Mongoose Schema ready to be used to compose other schemes and models.\n *\n * ### Example\n *\n * ```typescript\n * @MongooseSchema()\n * export class EventSchema {\n *   @Property()\n *   field: string;\n * }\n * ```\n *\n * ### Options\n *\n * - `schemaOptions` (mongoose.SchemaOptions): Option to configure the schema behavior.\n *\n * @param {MongooseSchemaOptions | undefined} options\n * @returns {(target: any) => void}\n * @decorator\n * @mongoose\n * @property\n * @class\n */\nexport function Schema(options?: MongooseSchemaOptions): (target: any) => void;\nexport function Schema(definition: SchemaTypeOptions<any>): Function;\nexport function Schema(options: MongooseSchemaOptions | SchemaTypeOptions<any> = {}) {\n  return (...parameters: any[]) => {\n    switch (decoratorTypeOf(parameters)) {\n      case \"property\":\n        return useDecorators(Property(), StoreMerge(MONGOOSE_SCHEMA, options))(parameters[0], parameters[1], parameters[2]);\n\n      case \"class\":\n        const {token} = getSchemaToken(parameters[0], options);\n\n        registerProvider({\n          provide: token,\n          deps: [],\n          useFactory() {\n            return getSchema(parameters[0], options as any);\n          }\n        });\n        break;\n    }\n  };\n}\n\n/**\n * Define a class as a Mongoose Schema ready to be used to compose other schemes and models.\n *\n * ### Example\n *\n * ```typescript\n * @MongooseSchema()\n * export class EventSchema {\n *   @Property()\n *   field: string;\n * }\n * ```\n *\n * ### Options\n *\n * - `schemaOptions` (mongoose.SchemaOptions): Option to configure the schema behavior.\n *\n * @param {MongooseSchemaOptions | undefined} options\n * @returns {(target: any) => void}\n * @decorator\n * @mongoose\n * @property\n * @class\n */\nexport function MongooseSchema(options?: MongooseSchemaOptions): (target: any) => void;\nexport function MongooseSchema(definition: SchemaTypeOptions<any>): Function;\nexport function MongooseSchema(options: MongooseSchemaOptions | SchemaTypeOptions<any> = {}) {\n  return Schema(options as any);\n}\n"]}

package/lib/decorators/schemaIgnore.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SchemaIgnore = void 0;
-const schema_1 = require("./schema");
-/**
- * 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 schema_1.MongooseSchema({ schemaIgnore: true });
-}
-exports.SchemaIgnore = SchemaIgnore;
-//# sourceMappingURL=schemaIgnore.js.map

package/lib/decorators/schemaIgnore.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"schemaIgnore.js","sourceRoot":"","sources":["../../src/decorators/schemaIgnore.ts"],"names":[],"mappings":";;;AAAA,qCAAwC;AAExC;;;;;;;;;;;;;;;;;GAiBG;AAEH,SAAgB,YAAY;IAC1B,OAAO,uBAAc,CAAC,EAAC,YAAY,EAAE,IAAI,EAAQ,CAAC,CAAC;AACrD,CAAC;AAFD,oCAEC","sourcesContent":["import {MongooseSchema} from \"./schema\";\n\n/**\n * Do not apply this property to schema (create virtual property)\n *\n * ### Example\n *\n * ```typescript\n * @Model()\n * @SchemaIgnore()\n * @Property()\n * kind: string;\n *\n * ```\n *\n * @returns {Function}\n * @decorator\n * @mongoose\n * @class\n */\n\nexport function SchemaIgnore(): Function {\n  return MongooseSchema({schemaIgnore: true} as any);\n}\n"]}

package/lib/decorators/select.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Select = void 0;
-const schema_1 = require("./schema");
-/**
- * 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 schema_1.MongooseSchema({ select });
-}
-exports.Select = Select;
-//# sourceMappingURL=select.js.map

package/lib/decorators/select.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"select.js","sourceRoot":"","sources":["../../src/decorators/select.ts"],"names":[],"mappings":";;;AAAA,qCAAwC;AAExC;;;;;;;;;;;;;;;;;;GAkBG;AACH,SAAgB,MAAM,CAAC,SAAwB,IAAI;IACjD,OAAO,uBAAc,CAAC,EAAC,MAAM,EAAC,CAAC,CAAC;AAClC,CAAC;AAFD,wBAEC","sourcesContent":["import {MongooseSchema} from \"./schema\";\n\n/**\n * Tell Mongoose to set default select() behavior for this path.\n *\n * ### Example\n *\n * ```typescript\n * @Model()\n * export class EventModel {\n *   @Select()\n *   field: string;\n * }\n * ```\n *\n * @param {boolean | any} select\n * @returns {Function}\n * @decorator\n * @mongoose\n * @property\n */\nexport function Select(select: boolean | any = true) {\n  return MongooseSchema({select});\n}\n"]}