@tsed/mongoose 8.11.1 → 8.12.0-rc.1

package/src/index.ts

@@ -1,47 +0,0 @@
-/**
- * @file Automatically generated by @tsed/barrels.
- */
-export * from "./constants/constants.js";
-export * from "./decorators/auto.js";
-export * from "./decorators/discriminatorKey.js";
-export * from "./decorators/dynamicRef.js";
-export * from "./decorators/excludeIndexes.js";
-export * from "./decorators/expires.js";
-export * from "./decorators/immutable.js";
-export * from "./decorators/indexed.js";
-export * from "./decorators/lowercase.js";
-export * from "./decorators/model.js";
-export * from "./decorators/mongooseIndex.js";
-export * from "./decorators/mongooseIndexes.js";
-export * from "./decorators/mongoosePlugin.js";
-export * from "./decorators/numberDecimal.js";
-export * from "./decorators/objectID.js";
-export * from "./decorators/postHook.js";
-export * from "./decorators/preHook.js";
-export * from "./decorators/ref.js";
-export * from "./decorators/schema.js";
-export * from "./decorators/schemaIgnore.js";
-export * from "./decorators/select.js";
-export * from "./decorators/sparse.js";
-export * from "./decorators/text.js";
-export * from "./decorators/trim.js";
-export * from "./decorators/unique.js";
-export * from "./decorators/uppercase.js";
-export * from "./decorators/versionKey.js";
-export * from "./decorators/virtualRef.js";
-export * from "./interfaces/interfaces.js";
-export * from "./interfaces/MongooseConnectionOptions.js";
-export * from "./interfaces/MongooseDocument.js";
-export * from "./interfaces/MongooseModel.js";
-export * from "./interfaces/MongooseModelOptions.js";
-export * from "./interfaces/MongooseSchemaOptions.js";
-export * from "./interfaces/MongooseSchemaTypes.js";
-export * from "./interfaces/MongooseVirtualRefOptions.js";
-export * from "./MongooseModule.js";
-export * from "./registries/MongooseModels.js";
-export * from "./services/MongooseConnections.js";
-export * from "./services/MongooseService.js";
-export * from "./utils/createModel.js";
-export * from "./utils/createSchema.js";
-export * from "./utils/resolveRefType.js";
-export * from "./utils/schemaOptions.js";

package/src/interfaces/MongooseConnectionOptions.ts

@@ -1,10 +0,0 @@
-import {ConnectOptions} from "mongoose";
-
-export interface MongooseConnectionOptions {
-  url: string;
-  /**
-   * The connection ID
-   */
-  id: string;
-  connectionOptions?: ConnectOptions;
-}

package/src/interfaces/MongooseDocument.ts

@@ -1,3 +0,0 @@
-import {Document} from "mongoose";
-
-export type MongooseDocument<T> = T & Document;

package/src/interfaces/MongooseModel.ts

@@ -1,10 +0,0 @@
-import {Document, Model} from "mongoose";
-
-// TODO since v5.11.5 Model require Document with id, See issue https://github.com/Automattic/mongoose/issues/9684
-export type MongooseMergedDocument<T> = {[K in keyof T]: T[K]};
-
-export interface MongooseDocumentMethods<T> {
-  toClass(): T;
-}
-
-export type MongooseModel<T> = Model<MongooseMergedDocument<Document & T & MongooseDocumentMethods<T>>>;

package/src/interfaces/MongooseModelOptions.ts

@@ -1,8 +0,0 @@
-import {MongooseSchemaOptions} from "./MongooseSchemaOptions.js";
-
-export interface MongooseModelOptions extends MongooseSchemaOptions {
-  name?: string;
-  connection?: string;
-  collection?: string;
-  overwriteModels?: boolean;
-}

package/src/interfaces/MongooseSchemaOptions.ts

@@ -1,61 +0,0 @@
-import {type IndexOptions, Schema, SchemaOptions} from "mongoose";
-
-import {MongooseDocument} from "./MongooseDocument.js";
-
-export type MongooseMethod =
-  | "aggregate"
-  | "bulkWrite"
-  | "createCollection"
-  | "save"
-  | "insertMany"
-  | "estimatedDocumentCount"
-  | "countDocuments"
-  | "deleteMany"
-  | "distinct"
-  | "find"
-  | "findOne"
-  | "findOneAndDelete"
-  | "findOneAndReplace"
-  | "findOneAndUpdate"
-  | "replaceOne"
-  | "updateMany"
-  | "init"
-  | "validate";
-
-export type MongooseMethods = MongooseMethod | RegExp | MongooseMethod[];
-
-export type MongooseNextCB = (err?: Error) => void;
-export type MongooseHookOptions = Record<string, unknown>;
-export type MongooseHookPromised<T = any> = (doc: T | MongooseDocument<T>) => Promise<void>;
-export type MongoosePreHookCB<T = any> = (doc: T | MongooseDocument<T>, ...args: unknown[]) => Promise<void> | void;
-export type MongoosePostHookCB<T = any> = (doc: T | MongooseDocument<T>, ...args: unknown[]) => Promise<void> | void;
-
-export interface MongoosePreHook<T = any> {
-  method: MongooseMethods;
-  fn: MongoosePreHookCB<T>;
-  options?: MongooseHookOptions;
-}
-
-export interface MongoosePostHook<T = any> {
-  method: MongooseMethods;
-  fn: MongoosePostHookCB<T>;
-  options?: MongooseHookOptions;
-}
-
-export interface MongoosePluginOptions {
-  plugin: (schema: Schema, options?: any) => void;
-  options?: Record<string, unknown>;
-}
-
-export interface MongooseIndexOptions {
-  fields: Record<any, any>;
-  options?: IndexOptions;
-}
-
-export interface MongooseSchemaOptions {
-  schemaOptions?: SchemaOptions;
-  plugins?: MongoosePluginOptions[];
-  indexes?: MongooseIndexOptions[];
-  pre?: MongoosePreHook[];
-  post?: MongoosePostHook[];
-}

package/src/interfaces/MongooseSchemaTypes.ts

@@ -1,5 +0,0 @@
-export enum MongooseSchemaTypes {
-  OBJECT_ID = "ObjectId",
-  STRING = "String",
-  NUMBER = "Number"
-}

package/src/interfaces/MongooseVirtualRefOptions.ts

@@ -1,10 +0,0 @@
-import {Type} from "@tsed/core";
-
-export interface MongooseVirtualRefOptions {
-  ref?: string | Type<any> | (() => Type<any>);
-  foreignField?: string;
-  localField?: string;
-  justOne?: boolean;
-  count?: boolean;
-  options?: object;
-}

package/src/interfaces/interfaces.ts

@@ -1,9 +0,0 @@
-import {MongooseConnectionOptions} from "./MongooseConnectionOptions.js";
-
-declare global {
-  namespace TsED {
-    interface Configuration {
-      mongoose: Omit<MongooseConnectionOptions, "id"> | MongooseConnectionOptions[];
-    }
-  }
-}

package/src/registries/MongooseModels.ts

@@ -1,3 +0,0 @@
-import {Type} from "@tsed/core";
-
-export const MongooseModels: Map<string, Type> = new Map();

package/src/services/MongooseConnection.spec.ts

@@ -1,70 +0,0 @@
-import {Configuration} from "@tsed/di";
-import {PlatformTest} from "@tsed/platform-http/testing";
-
-import {MongooseService} from "../../src/index.js";
-import {MONGOOSE_CONNECTIONS} from "../../src/services/MongooseConnections.js";
-
-describe("MongooseConnections", () => {
-  beforeEach(PlatformTest.create);
-  afterEach(PlatformTest.reset);
-
-  it("should init connection with url", async () => {
-    // GIVEN
-    const connectStub = vi.fn().mockResolvedValue("test");
-
-    // WHEN
-    await PlatformTest.invoke(MONGOOSE_CONNECTIONS, [
-      {
-        token: Configuration,
-        use: {
-          get() {
-            return {
-              url: "mongodb://test",
-              connectionOptions: {options: "options"}
-            };
-          }
-        }
-      },
-      {
-        token: MongooseService,
-        use: {
-          connect: connectStub
-        }
-      }
-    ]);
-
-    // THEN
-    expect(connectStub).toHaveBeenCalledWith("default", "mongodb://test", {options: "options"}, true);
-  });
-  it("should init with a list of connection", async () => {
-    // GIVEN
-    const connectStub = vi.fn().mockResolvedValue("test");
-
-    // WHEN
-    await PlatformTest.invoke(MONGOOSE_CONNECTIONS, [
-      {
-        token: Configuration,
-        use: {
-          get() {
-            return [
-              {
-                id: "id",
-                url: "mongodb://test",
-                connectionOptions: {options: "options"}
-              }
-            ];
-          }
-        }
-      },
-      {
-        token: MongooseService,
-        use: {
-          connect: connectStub
-        }
-      }
-    ]);
-
-    // THEN
-    expect(connectStub).toHaveBeenCalledWith("id", "mongodb://test", {options: "options"}, true);
-  });
-});

package/src/services/MongooseConnections.ts

@@ -1,58 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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

@@ -1,77 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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;
-}