@tsed/mongoose 8.0.1 → 8.0.2

package/src/services/MongooseConnections.ts

@@ -0,0 +1,58 @@
+import {isArray} from "@tsed/core";
+import {Configuration, registerProvider} from "@tsed/di";
+
+import {MongooseConnectionOptions} from "../interfaces/MongooseConnectionOptions.js";
+import {MongooseService} from "../services/MongooseService.js";
+
+/**
+ * @ignore
+ */
+// tslint:disable-next-line:variable-name
+export const MONGOOSE_CONNECTIONS = Symbol.for("MONGOOSE_CONNECTIONS");
+/**
+ * @ignore
+ */
+export type MONGOOSE_CONNECTIONS = MongooseService;
+
+function mapOptions(options: Omit<MongooseConnectionOptions, "id"> | MongooseConnectionOptions[]): MongooseConnectionOptions[] {
+  if (!options) {
+    return [];
+  }
+
+  if (!isArray(options)) {
+    const {url, connectionOptions} = options || {};
+
+    return [
+      {
+        id: "default",
+        url,
+        connectionOptions
+      }
+    ];
+  }
+
+  return (options as MongooseConnectionOptions[]).map((settings) => {
+    return {
+      ...settings,
+      connectionOptions: settings.connectionOptions
+    };
+  });
+}
+
+registerProvider({
+  token: MONGOOSE_CONNECTIONS,
+  injectable: false,
+  deps: [Configuration, MongooseService],
+  async useAsyncFactory(configuration: Configuration, mongooseService: MongooseService) {
+    const settings = mapOptions(configuration.get<MongooseConnectionOptions | MongooseConnectionOptions[]>("mongoose"));
+    let isDefault = true;
+
+    for (const current of settings) {
+      await mongooseService.connect(current.id, current.url, current.connectionOptions || {}, isDefault);
+
+      isDefault = false;
+    }
+
+    return mongooseService;
+  }
+});

package/src/services/MongooseService.spec.ts

@@ -0,0 +1,73 @@
+import {PlatformTest} from "@tsed/platform-http/testing";
+import Mongoose from "mongoose";
+
+import {MongooseService} from "../../src/index.js";
+
+describe("Mongoose", () => {
+  describe("MongooseService", () => {
+    beforeEach(async () => {
+      await PlatformTest.create({
+        logger: {
+          level: "off"
+        }
+      });
+    });
+
+    afterEach(async () => {
+      await PlatformTest.reset();
+    });
+
+    it("should call mongoose.connect", async () => {
+      const mongooseService = PlatformTest.get<MongooseService>(MongooseService);
+      // GIVEN
+      const instance = {
+        readyState: 1,
+        close: vi.fn()
+      };
+
+      (Mongoose.createConnection as any) = vi.fn().mockResolvedValue(instance);
+
+      // WHEN
+      await mongooseService.connect("key", "mongodb://test", {options: "options"} as any);
+
+      const result = await mongooseService.connect("key", "mongodb://test", {options: "options"} as any);
+
+      // THEN
+      expect(result).toBe(instance);
+      expect(Mongoose.createConnection).toHaveBeenNthCalledWith(1, "mongodb://test", {options: "options"});
+      expect(mongooseService.get()).toBeUndefined();
+      expect(mongooseService.has()).toBe(false);
+    });
+
+    it("should close connection (1)", async () => {
+      const mongooseService = PlatformTest.get<MongooseService>(MongooseService);
+      // GIVEN
+      const instance = {
+        close: vi.fn()
+      };
+      (Mongoose.createConnection as any) = vi.fn().mockResolvedValue(instance);
+
+      // WHEN
+      await mongooseService.connect("key1", "mongodb://test", {options: "options"} as any);
+      await mongooseService.closeConnections();
+
+      // THEN
+      expect(instance.close).toHaveBeenCalledWith();
+    });
+    it("should close connection (2)", async () => {
+      const mongooseService = PlatformTest.get<MongooseService>(MongooseService);
+      // GIVEN
+      const instance = {
+        close: vi.fn()
+      };
+      (Mongoose.createConnection as any) = vi.fn().mockResolvedValue(instance);
+
+      // WHEN
+      await mongooseService.connect("key2", "mongodb://test", {options: "options"} as any);
+      await mongooseService.closeConnections();
+
+      // THEN
+      expect(instance.close).toHaveBeenCalledWith();
+    });
+  });
+});

package/src/services/MongooseService.ts

@@ -0,0 +1,77 @@
+import {Inject, Injectable} from "@tsed/di";
+import {Logger} from "@tsed/logger";
+import Mongoose from "mongoose";
+import {ConnectOptions} from "mongoose";
+
+// istanbul ignore next
+function asPromise(c: any) {
+  return c && c.asPromise ? c.asPromise() : c;
+}
+
+@Injectable()
+export class MongooseService {
+  readonly connections: Map<string, Mongoose.Connection> = new Map();
+  private defaultConnection: string = "default";
+
+  @Inject()
+  logger: Logger;
+
+  /**
+   *
+   * @returns {Promise<"mongoose".Connection>}
+   */
+  async connect(id: string, url: string, connectionOptions: ConnectOptions, isDefault = false): Promise<any> {
+    if (this.has(id)) {
+      return this.get(id)!;
+    }
+
+    this.logger.info(`Connect to mongo database: ${id}`);
+    this.logger.debug(`Url: ${url}`);
+    this.logger.debug(`options: ${JSON.stringify(connectionOptions)}`);
+
+    try {
+      const connection = await asPromise(Mongoose.createConnection(url, connectionOptions));
+      this.connections.set(id, connection);
+
+      if (id === "default" || isDefault) {
+        this.defaultConnection = id;
+      }
+
+      return connection;
+    } catch (er) {
+      /* istanbul ignore next */
+      this.logger.error({
+        event: "MONGO_CONNECTION_ERROR",
+        error_name: er.name,
+        message: er.message,
+        stack: er.stack
+      });
+      /* istanbul ignore next */
+      process.exit();
+    }
+  }
+
+  /**
+   *
+   * @returns {"mongoose".Connection}
+   */
+  get(id?: string): Mongoose.Connection | undefined {
+    return this.connections.get(id || this.defaultConnection);
+  }
+
+  /**
+   *
+   * @param {string} id
+   * @returns {boolean}
+   */
+  has(id?: string): boolean {
+    return this.connections.has(id || this.defaultConnection);
+  }
+
+  async closeConnections() {
+    for (const [id, connection] of this.connections.entries()) {
+      await connection.close();
+      this.connections.delete(id);
+    }
+  }
+}

package/src/utils/buildMongooseSchema.spec.ts

@@ -0,0 +1,67 @@
+import {JsonEntityStore, Property} from "@tsed/schema";
+import {Types} from "mongoose";
+
+import {buildMongooseSchema} from "../../src/utils/createSchema.js";
+import {MONGOOSE_SCHEMA} from "../constants/constants.js";
+
+describe("buildMongooseSchema", () => {
+  describe("when mongoose schema hasn't ref", () => {
+    it("should return schema", () => {
+      class Test {
+        @Property()
+        _id: string;
+
+        @Property()
+        test: String;
+      }
+
+      // WHEN
+      const result = buildMongooseSchema(Test);
+
+      // THEN
+      expect(result.schema).toEqual({
+        _id: {
+          required: false,
+          type: String
+        },
+        test: {
+          required: false,
+          type: String
+        }
+      });
+
+      expect(result.virtuals.size).toBe(0);
+    });
+  });
+
+  describe("when mongoose schema has virtual ref", () => {
+    it("should return schema", () => {
+      class Test {
+        test: String;
+      }
+
+      const propertyMetadata = JsonEntityStore.get(Test, "test");
+      propertyMetadata.type = String;
+      propertyMetadata.store.set(MONGOOSE_SCHEMA, {
+        ref: "ref",
+        justOne: true,
+        localField: "localField",
+        foreignField: "foreignField"
+      });
+
+      // WHEN
+      const result = buildMongooseSchema(Test);
+
+      // THEN
+      expect(result.schema).toEqual({});
+
+      expect(result.virtuals.size).toBe(1);
+      expect(result.virtuals.get("test")).toEqual({
+        foreignField: "foreignField",
+        justOne: true,
+        localField: "localField",
+        ref: "ref"
+      });
+    });
+  });
+});

package/src/utils/createModel.spec.ts

@@ -0,0 +1,49 @@
+import mongoose from "mongoose";
+
+import {createModel} from "../../src/index.js";
+
+describe("createModel()", () => {
+  let schema: any;
+  mongoose.model = vi.fn();
+  describe("when the model name is given", () => {
+    class Test {}
+
+    beforeEach(() => {
+      schema = {};
+      createModel(Test, schema, "name", "collection", true);
+    });
+
+    it("should call mongoose.model", () => {
+      expect(mongoose.model).toHaveBeenCalledWith("name", schema, "collection", {overwriteModels: true});
+    });
+  });
+
+  describe("when the model name is not given", () => {
+    class Test {}
+
+    beforeEach(() => {
+      schema = {};
+
+      createModel(Test, schema);
+    });
+
+    it("should call mongoose.model", () => {
+      expect(mongoose.model).toHaveBeenCalledWith("Test", schema, undefined, undefined);
+    });
+  });
+
+  describe("when the model is derived and parent has no discriminator key", () => {
+    class TestParent {}
+
+    class TestChild extends TestParent {}
+
+    beforeEach(() => {
+      schema = {};
+      createModel(TestChild, schema);
+    });
+
+    it("should call mongoose.model", () => {
+      expect(mongoose.model).toHaveBeenCalledWith("TestChild", schema, undefined, undefined);
+    });
+  });
+});

package/src/utils/createModel.ts

@@ -0,0 +1,54 @@
+import {nameOf, Store, Type} from "@tsed/core";
+import {JsonEntityStore} from "@tsed/schema";
+import mongoose, {Connection} from "mongoose";
+
+import {MONGOOSE_MODEL, MONGOOSE_MODEL_NAME} from "../constants/constants.js";
+import {MongooseModels} from "../registries/MongooseModels.js";
+import {getSchemaToken} from "./createSchema.js";
+
+export function getModelToken(target: Type<any>, options: any) {
+  const {collectionName, token} = getSchemaToken(target, options);
+
+  Store.from(target).set(MONGOOSE_MODEL_NAME, collectionName);
+  MongooseModels.set(collectionName, target);
+
+  return {token, collectionName};
+}
+
+/**
+ * Create an instance of mongoose.model from a class.
+ *
+ * @param {Type<any>} target Class attached to the schema and model.
+ * @param {"mongoose".Schema} schema Schema that will be attached to the model.
+ * @param name model name
+ * @param collection (optional, induced from model name)
+ * @param overwriteModels
+ * @param connection
+ * @returns {Model<T extends Document>}
+ */
+export function createModel<T>(
+  target: any,
+  schema: mongoose.Schema,
+  name: string = nameOf(target),
+  collection?: string,
+  overwriteModels?: boolean,
+  connection?: Connection
+) {
+  const entity = JsonEntityStore.from(target);
+
+  if (entity.isDiscriminatorChild) {
+    const discriminatorName = entity.discriminatorAncestor!.schema.discriminator().getDefaultValue(target)!;
+    const ancestorModel = entity.discriminatorAncestor!.get(MONGOOSE_MODEL);
+
+    // check if discriminator is already registered on model before creating it
+    return ancestorModel.discriminators?.[discriminatorName] || ancestorModel.discriminator(discriminatorName, schema);
+  }
+
+  const opts = overwriteModels ? {overwriteModels} : undefined;
+  const c = connection || mongoose;
+
+  const model = c.model(name, schema, collection, opts);
+  Store.from(target).set(MONGOOSE_MODEL, model);
+
+  return model;
+}