@tsed/mongoose 8.0.1 → 8.0.3

package/package.json

@@ -2,7 +2,7 @@
   "name": "@tsed/mongoose",
   "description": "Mongoose package for Ts.ED framework",
   "type": "module",
-  "version": "8.0.1",
+  "version": "8.0.3",
   "keywords": [
     "tsed",
     "mongoose",
@@ -16,6 +16,7 @@
   "typings": "./lib/types/index.d.ts",
   "exports": {
     ".": {
+      "@tsed/source": "./src/index.ts",
       "types": "./lib/types/index.d.ts",
       "import": "./lib/esm/index.js",
       "default": "./lib/esm/index.js"
@@ -33,27 +34,27 @@
     "tslib": "2.7.0"
   },
   "devDependencies": {
-    "@tsed/ajv": "8.0.1",
-    "@tsed/barrels": "8.0.1",
-    "@tsed/core": "8.0.1",
-    "@tsed/di": "8.0.1",
-    "@tsed/json-mapper": "8.0.1",
+    "@tsed/ajv": "8.0.3",
+    "@tsed/barrels": "8.0.3",
+    "@tsed/core": "8.0.3",
+    "@tsed/di": "8.0.3",
+    "@tsed/json-mapper": "8.0.3",
     "@tsed/logger": "^6.7.8",
-    "@tsed/schema": "8.0.1",
-    "@tsed/testcontainers-mongo": "8.0.1",
-    "@tsed/typescript": "8.0.1",
+    "@tsed/schema": "8.0.3",
+    "@tsed/testcontainers-mongo": "8.0.3",
+    "@tsed/typescript": "8.0.3",
     "eslint": "9.12.0",
     "mongoose": "8.7.0",
     "typescript": "5.4.5",
     "vitest": "2.1.2"
   },
   "peerDependencies": {
-    "@tsed/ajv": "8.0.1",
-    "@tsed/core": "8.0.1",
-    "@tsed/di": "8.0.1",
-    "@tsed/json-mapper": "8.0.1",
+    "@tsed/ajv": "8.0.3",
+    "@tsed/core": "8.0.3",
+    "@tsed/di": "8.0.3",
+    "@tsed/json-mapper": "8.0.3",
     "@tsed/logger": ">=6.7.5",
-    "@tsed/schema": "8.0.1",
+    "@tsed/schema": "8.0.3",
     "mongoose": ">=6.0.0"
   },
   "repository": "https://github.com/tsedio/tsed",

package/readme.md

@@ -1,5 +1,5 @@
 <p style="text-align: center" align="center">
- <a href="https://tsed.io" target="_blank"><img src="https://tsed.io/tsed-og.png" width="200" alt="Ts.ED logo"/></a>
+ <a href="https://tsed.dev" target="_blank"><img src="https://tsed.dev/tsed-og.png" width="200" alt="Ts.ED logo"/></a>
 </p>
 
 <div align="center">
@@ -16,9 +16,9 @@
 </div>
 
 <div align="center">
-  <a href="https://tsed.io/">Website</a>
+  <a href="https://tsed.dev/">Website</a>
   <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
-  <a href="https://tsed.io/getting-started/">Getting started</a>
+  <a href="https://tsed.dev/getting-started/">Getting started</a>
   <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
   <a href="https://api.tsed.io/rest/slack/tsedio/tsed">Slack</a>
   <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
@@ -27,7 +27,7 @@
 
 <hr />
 
-A package of Ts.ED framework. See website: https://tsed.io/tutorials/mongoose.html
+A package of Ts.ED framework. See website: https://tsed.dev/tutorials/mongoose.html
 
 ## Features
 
@@ -345,7 +345,7 @@ For further information, please refer to the [mongoose documentation about discr
 
 ## Contributors
 
-Please read [contributing guidelines here](https://tsed.io/contributing.html)
+Please read [contributing guidelines here](https://tsed.dev/contributing.html)
 
 <a href="https://github.com/tsedio/tsed/graphs/contributors"><img src="https://opencollective.com/tsed/contributors.svg?width=890" /></a>
 

package/src/MongooseModule.ts

@@ -0,0 +1,32 @@
+import {Configuration, OnInit} from "@tsed/di";
+import {Module, OnDestroy} from "@tsed/di";
+
+import {MONGOOSE_CONNECTIONS} from "./services/MongooseConnections.js";
+import {MongooseService} from "./services/MongooseService.js";
+
+/**
+ * @ignore
+ */
+@Module({
+  imports: [MONGOOSE_CONNECTIONS]
+})
+export class MongooseModule implements OnDestroy, OnInit {
+  constructor(
+    private mongooseService: MongooseService,
+    @Configuration() private settings: Configuration
+  ) {
+    // auto configure the cache manager when mongoose is used with @tsed/mongoose
+    const cache = this.settings.get<any>("cache");
+
+    // istanbul ignore next
+    if (cache?.mongoose) {
+      cache.connection = this.mongooseService.get();
+    }
+  }
+
+  $onInit(): void | Promise<any> {}
+
+  $onDestroy(): Promise<any> | void {
+    return this.mongooseService.closeConnections();
+  }
+}

package/src/constants/constants.ts

@@ -0,0 +1,20 @@
+/**
+ *
+ * @type {string}
+ */
+export const MONGOOSE_SCHEMA = "tsed:mongoose:schema";
+/**
+ *
+ * @type {string}
+ */
+export const MONGOOSE_SCHEMA_OPTIONS = "tsed:mongoose:schema:options";
+/**
+ *
+ * @type {string}
+ */
+export const MONGOOSE_MODEL = "tsed:mongoose:model";
+/**
+ *
+ * @type {string}
+ */
+export const MONGOOSE_MODEL_NAME = "tsed:mongoose:model:name";

package/src/decorators/auto.spec.ts

@@ -0,0 +1,30 @@
+import {descriptorOf, Store} from "@tsed/core";
+
+import {MONGOOSE_SCHEMA} from "../constants/constants.js";
+import {Auto} from "./auto.js";
+
+describe("@Auto()", () => {
+  it("should set metadata (default)", () => {
+    class Test {
+      @Auto()
+      test: string;
+    }
+
+    const store = Store.from(Test, "test", descriptorOf(Test, "test"));
+    expect(store.get(MONGOOSE_SCHEMA)).toEqual({
+      auto: true
+    });
+  });
+
+  it("should set metadata (true)", () => {
+    class Test {
+      @Auto(true)
+      test: string;
+    }
+
+    const store = Store.from(Test, "test", descriptorOf(Test, "test"));
+    expect(store.get(MONGOOSE_SCHEMA)).toEqual({
+      auto: true
+    });
+  });
+});

package/src/decorators/auto.ts

@@ -0,0 +1,24 @@
+import {MongooseSchema} from "./schema.js";
+
+/**
+ * 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
+ */
+export function Auto(auto: boolean = true): PropertyDecorator {
+  return MongooseSchema({auto} as any);
+}

package/src/decorators/discriminatorKey.ts

@@ -0,0 +1 @@
+export {DiscriminatorKey} from "@tsed/schema";

package/src/decorators/dynamicRef.spec.ts

@@ -0,0 +1,46 @@
+import {descriptorOf, Store} from "@tsed/core";
+import {getJsonSchema} from "@tsed/schema";
+import {Schema} from "mongoose";
+
+import {DynamicRef} from "../../src/index.js";
+import {MONGOOSE_MODEL_NAME, MONGOOSE_SCHEMA} from "../constants/constants.js";
+
+describe("@DynamicRef()", () => {
+  it("should set metadata", () => {
+    // GIVEN
+    class RefTest {}
+
+    Store.from(RefTest).set(MONGOOSE_MODEL_NAME, "RefTest");
+
+    // WHEN
+    class Test {
+      @DynamicRef("RefTest")
+      test: DynamicRef<RefTest>;
+    }
+
+    // THEN
+    expect(getJsonSchema(Test)).toEqual({
+      properties: {
+        test: {
+          description: "A reference ObjectID",
+          examples: ["5ce7ad3028890bd71749d477"],
+          oneOf: [
+            {
+              description: "A reference ObjectID",
+              examples: ["5ce7ad3028890bd71749d477"],
+              type: "string"
+            }
+          ]
+        }
+      },
+      type: "object"
+    });
+
+    const store = Store.from(Test, "test", descriptorOf(Test, "test"));
+
+    expect(store.get(MONGOOSE_SCHEMA)).toEqual({
+      type: Schema.Types.ObjectId,
+      refPath: "RefTest"
+    });
+  });
+});

package/src/decorators/dynamicRef.ts

@@ -0,0 +1,76 @@
+import {classOf, isArrowFn, isString, StoreMerge, Type, useDecorators} from "@tsed/core";
+import {deserialize, OnDeserialize, OnSerialize, serialize} from "@tsed/json-mapper";
+import {Description, Example, JsonHookContext, OneOf, Property, string} from "@tsed/schema";
+import {Schema as MongooseSchema} from "mongoose";
+
+import {MONGOOSE_SCHEMA} from "../constants/constants.js";
+import {MongooseModels} from "../registries/MongooseModels.js";
+
+function isRef(value: undefined | string | any) {
+  return (value && value._bsontype) || isString(value);
+}
+
+function getType(refPath: string, ctx: JsonHookContext) {
+  return (ctx?.self[refPath] && MongooseModels.get(ctx.self[refPath] as string)) || Object;
+}
+
+/**
+ * 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 {String} the path to apply the correct model
+ * @param types {Type} the classes to generate the correct json schema
+ * @returns {Function}
+ * @decorator
+ * @mongoose
+ * @property
+ */
+export function DynamicRef(refPath: string, ...types: Type<any>[]): PropertyDecorator {
+  return useDecorators(
+    Property(Object),
+    Example("5ce7ad3028890bd71749d477"),
+    Description("A reference ObjectID"),
+    StoreMerge(MONGOOSE_SCHEMA, {
+      type: MongooseSchema.Types.ObjectId,
+      refPath
+    }),
+    OnDeserialize((value, ctx) => {
+      if (isRef(value)) {
+        return value.toString();
+      }
+
+      return deserialize(value, {...ctx, type: getType(refPath, ctx)});
+    }),
+    OnSerialize((value: any, ctx) => {
+      if (isRef(value)) {
+        return value.toString();
+      }
+
+      return serialize(value, {...ctx, type: getType(refPath, ctx)});
+    }),
+    OneOf(string().example("5ce7ad3028890bd71749d477").description("A reference ObjectID"), ...types)
+  ) as PropertyDecorator;
+}
+
+export type DynamicRef<T> = T | string;

package/src/decorators/excludeIndexes.spec.ts

@@ -0,0 +1,30 @@
+import {descriptorOf, Store} from "@tsed/core";
+
+import {MONGOOSE_SCHEMA} from "../constants/constants.js";
+import {ExcludeIndexes} from "./excludeIndexes.js";
+
+describe("@ExcludeIndexes()", () => {
+  it("should set metadata (default)", () => {
+    class Test {
+      @ExcludeIndexes()
+      test: string;
+    }
+
+    const store = Store.from(Test, "test", descriptorOf(Test, "test"));
+    expect(store.get(MONGOOSE_SCHEMA)).toEqual({
+      excludeIndexes: true
+    });
+  });
+
+  it("should set metadata (true)", () => {
+    class Test {
+      @ExcludeIndexes(true)
+      test: string;
+    }
+
+    const store = Store.from(Test, "test", descriptorOf(Test, "test"));
+    expect(store.get(MONGOOSE_SCHEMA)).toEqual({
+      excludeIndexes: true
+    });
+  });
+});

package/src/decorators/excludeIndexes.ts

@@ -0,0 +1,24 @@
+import {MongooseSchema} from "./schema.js";
+
+/**
+ * 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
+ */
+export function ExcludeIndexes(excludeIndexes: boolean = true): PropertyDecorator {
+  return MongooseSchema({excludeIndexes} as any);
+}

package/src/decorators/expires.spec.ts

@@ -0,0 +1,18 @@
+import {descriptorOf, Store} from "@tsed/core";
+
+import {MONGOOSE_SCHEMA} from "../constants/constants.js";
+import {Expires} from "./expires.js";
+
+describe("@Expires()", () => {
+  it("should set metadata", () => {
+    class Test {
+      @Expires("5d")
+      test: string;
+    }
+
+    const store = Store.from(Test, "test", descriptorOf(Test, "test"));
+    expect(store.get(MONGOOSE_SCHEMA)).toEqual({
+      expires: "5d"
+    });
+  });
+});

package/src/decorators/expires.ts

@@ -0,0 +1,24 @@
+import {MongooseSchema} from "./schema.js";
+
+/**
+ * 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
+ */
+export function Expires(expires: number | string | Date): PropertyDecorator {
+  return MongooseSchema({expires} as any);
+}

package/src/decorators/immutable.spec.ts

@@ -0,0 +1,30 @@
+import {descriptorOf, Store} from "@tsed/core";
+
+import {MONGOOSE_SCHEMA} from "../constants/constants.js";
+import {Immutable} from "./immutable.js";
+
+describe("@Immutable()", () => {
+  it("should set metadata (default)", () => {
+    class Test {
+      @Immutable()
+      test: string;
+    }
+
+    const store = Store.from(Test, "test", descriptorOf(Test, "test"));
+    expect(store.get(MONGOOSE_SCHEMA)).toEqual({
+      immutable: true
+    });
+  });
+
+  it("should set metadata (true)", () => {
+    class Test {
+      @Immutable(true)
+      test: string;
+    }
+
+    const store = Store.from(Test, "test", descriptorOf(Test, "test"));
+    expect(store.get(MONGOOSE_SCHEMA)).toEqual({
+      immutable: true
+    });
+  });
+});

package/src/decorators/immutable.ts

@@ -0,0 +1,26 @@
+import {MongooseSchema} from "./schema.js";
+
+/**
+ * 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
+ */
+export function Immutable(immutable: boolean | ((this: any, doc: any) => boolean) = true): PropertyDecorator {
+  return MongooseSchema({immutable} as any);
+}

package/src/decorators/indexed.spec.ts

@@ -0,0 +1,19 @@
+import {Store} from "@tsed/core";
+
+import {MONGOOSE_SCHEMA} from "../constants/constants.js";
+import {Indexed} from "./indexed.js";
+
+describe("@Indexed()", () => {
+  it("should set metadata", () => {
+    class Test {
+      @Indexed()
+      test: string;
+    }
+
+    const store = Store.from(Test, "test");
+
+    expect(store.get(MONGOOSE_SCHEMA)).toEqual({
+      index: true
+    });
+  });
+});

package/src/decorators/indexed.ts

@@ -0,0 +1,24 @@
+import {IndexOptions} from "mongoose";
+
+import {MongooseSchema} from "./schema.js";
+
+/**
+ * Tell Mongoose whether to define an index for the property.
+ * ### Example
+ *
+ * ```typescript
+ * @Model()
+ * export class EventModel {
+ *   @Indexed()
+ *   field: string;
+ * }
+ * ```
+ *
+ * @returns {Function}
+ * @decorator
+ * @mongoose
+ * @property
+ */
+export function Indexed(index: IndexOptions | boolean | string = true): PropertyDecorator {
+  return MongooseSchema({index} as any);
+}

package/src/decorators/lowercase.spec.ts

@@ -0,0 +1,30 @@
+import {descriptorOf, Store} from "@tsed/core";
+
+import {MONGOOSE_SCHEMA} from "../constants/constants.js";
+import {Lowercase} from "./lowercase.js";
+
+describe("@Lowercase()", () => {
+  it("should set metadata (default)", () => {
+    class Test {
+      @Lowercase()
+      test: string;
+    }
+
+    const store = Store.from(Test, "test", descriptorOf(Test, "test"));
+    expect(store.get(MONGOOSE_SCHEMA)).toEqual({
+      lowercase: true
+    });
+  });
+
+  it("should set metadata (true)", () => {
+    class Test {
+      @Lowercase(true)
+      test: string;
+    }
+
+    const store = Store.from(Test, "test", descriptorOf(Test, "test"));
+    expect(store.get(MONGOOSE_SCHEMA)).toEqual({
+      lowercase: true
+    });
+  });
+});

package/src/decorators/lowercase.ts

@@ -0,0 +1,24 @@
+import {MongooseSchema} from "./schema.js";
+
+/**
+ * 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
+ */
+export function Lowercase(lowercase: boolean = true): PropertyDecorator {
+  return MongooseSchema({lowercase} as any);
+}

package/src/decorators/model.ts

@@ -0,0 +1,69 @@
+import {useDecorators} from "@tsed/core";
+import {injectable} from "@tsed/di";
+import {Schema} from "mongoose";
+
+import {MongooseModelOptions} from "../interfaces/MongooseModelOptions.js";
+import {MONGOOSE_CONNECTIONS} from "../services/MongooseConnections.js";
+import {createModel, getModelToken} from "../utils/createModel.js";
+import {getSchema} from "../utils/createSchema.js";
+import {applySchemaOptions, schemaOptions} from "../utils/schemaOptions.js";
+
+/**
+ * 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
+ */
+export function Model(options: MongooseModelOptions = {}) {
+  return useDecorators((target: any) => {
+    const {token, collectionName} = getModelToken(target, options);
+
+    injectable(token).factory(() => getSchema(target, options as any));
+
+    injectable(target)
+      .type("mongoose:model")
+      .deps([MONGOOSE_CONNECTIONS, token])
+      .factory((connections: MONGOOSE_CONNECTIONS, schema: Schema) => {
+        applySchemaOptions(schema, schemaOptions(target));
+        return createModel(
+          target,
+          schema,
+          collectionName,
+          options.collection,
+          options.overwriteModels,
+          connections.get(options.connection)
+        );
+      });
+  });
+}