@tsed/mongoose 8.0.1 → 8.0.2

package/src/decorators/virtualRef.spec.ts

@@ -0,0 +1,383 @@
+import {Store} from "@tsed/core";
+import {Controller} from "@tsed/di";
+import {BodyParams} from "@tsed/platform-params";
+import {Format, getJsonSchema, getSpec, Post, Property, ReadOnly, Returns, SpecTypes} from "@tsed/schema";
+
+import {MONGOOSE_SCHEMA} from "../constants/constants.js";
+import {Model} from "./model.js";
+import {VirtualRef, VirtualRefs} from "./virtualRef.js";
+
+describe("@VirtualRef()", () => {
+  describe("when type and foreign value are given", () => {
+    it("should set metadata", () => {
+      // WHEN
+      class Test {
+        @VirtualRef("RefTest", "foreign")
+        test: any;
+      }
+
+      // THEN
+      const store = Store.from(Test, "test");
+
+      expect(store.get(MONGOOSE_SCHEMA)).toEqual({
+        ref: "RefTest",
+        justOne: false,
+        count: false,
+        foreignField: "foreign",
+        localField: "_id",
+        options: undefined
+      });
+    });
+  });
+
+  describe("when options is given with minimal fields", () => {
+    it("should set metadata", () => {
+      // WHEN
+      class Test {
+        @VirtualRef({ref: "RefTest", foreignField: "foreign"})
+        test: any;
+      }
+
+      // THEN
+      const store = Store.from(Test, "test");
+
+      expect(store.get(MONGOOSE_SCHEMA)).toEqual({
+        ref: "RefTest",
+        localField: "_id",
+        foreignField: "foreign",
+        justOne: false,
+        count: false,
+        options: undefined
+      });
+    });
+  });
+
+  describe("when options is given with all fields", () => {
+    it("should set metadata", () => {
+      // WHEN
+      class Test {
+        @VirtualRef({
+          ref: "RefTest",
+          foreignField: "foreign",
+          localField: "test_2",
+          justOne: true,
+          count: true,
+          options: {}
+        })
+        test: any;
+      }
+
+      // THEN
+      const store = Store.from(Test, "test");
+
+      expect(store.get(MONGOOSE_SCHEMA)).toEqual({
+        ref: "RefTest",
+        localField: "test_2",
+        foreignField: "foreign",
+        justOne: true,
+        count: true,
+        options: {}
+      });
+    });
+  });
+
+  describe("with a given model", () => {
+    it("should set metadata", () => {
+      @Model({name: "VirtualTestPerson"})
+      class TestPerson {
+        @Property()
+        name: string;
+
+        @Property()
+        band: string;
+      }
+
+      // WHEN
+      @Model({name: "VirtualTestBand"})
+      class TestBand {
+        @VirtualRef({
+          ref: TestPerson,
+          foreignField: "foreign",
+          localField: "test_2",
+          justOne: true,
+          count: false,
+          options: {}
+        })
+        members: VirtualRef<TestPerson>;
+      }
+
+      // THEN
+      const store = Store.from(TestBand, "members");
+
+      expect(store.get(MONGOOSE_SCHEMA)).toEqual({
+        ref: "VirtualTestPerson",
+        localField: "test_2",
+        foreignField: "foreign",
+        justOne: true,
+        count: false,
+        options: {}
+      });
+
+      expect(getJsonSchema(TestBand)).toEqual({
+        definitions: {
+          TestPerson: {
+            properties: {
+              band: {
+                type: "string"
+              },
+              name: {
+                type: "string"
+              }
+            },
+            type: "object"
+          }
+        },
+        properties: {
+          members: {
+            $ref: "#/definitions/TestPerson"
+          }
+        },
+        type: "object"
+      });
+    });
+    it("should generate spec", () => {
+      @Model({name: "VirtualTestPerson"})
+      class TestPerson {
+        @Property()
+        name: string;
+
+        @Property()
+        band: string;
+      }
+
+      // WHEN
+      @Model({name: "VirtualTestBand"})
+      class TestBand {
+        @Format("date-time")
+        @ReadOnly()
+        createdAt: number = Date.now();
+
+        @Format("date-time")
+        @ReadOnly()
+        updatedAt: number = Date.now();
+
+        @ReadOnly()
+        @VirtualRef({
+          ref: TestPerson,
+          foreignField: "foreign",
+          localField: "test_2",
+          justOne: true,
+          options: {}
+        })
+        members: VirtualRef<TestPerson>;
+      }
+
+      @Controller("/")
+      class MyCtrl {
+        @Post("/")
+        @Returns(200, TestBand)
+        post(@BodyParams() model: TestBand) {}
+      }
+
+      // THEN
+      const store = Store.from(TestBand, "members");
+
+      expect(store.get(MONGOOSE_SCHEMA)).toEqual({
+        ref: "VirtualTestPerson",
+        localField: "test_2",
+        foreignField: "foreign",
+        justOne: true,
+        count: false,
+        options: {}
+      });
+
+      expect(getSpec(MyCtrl, {specType: SpecTypes.OPENAPI})).toEqual({
+        components: {
+          schemas: {
+            TestBand: {
+              properties: {
+                createdAt: {
+                  format: "date-time",
+                  readOnly: true,
+                  type: "number"
+                },
+                members: {
+                  anyOf: [
+                    {
+                      $ref: "#/components/schemas/TestPerson"
+                    }
+                  ],
+                  readOnly: true
+                },
+                updatedAt: {
+                  format: "date-time",
+                  readOnly: true,
+                  type: "number"
+                }
+              },
+              type: "object"
+            },
+            TestPerson: {
+              properties: {
+                band: {
+                  type: "string"
+                },
+                name: {
+                  type: "string"
+                }
+              },
+              type: "object"
+            }
+          }
+        },
+        paths: {
+          "/": {
+            post: {
+              operationId: "myCtrlPost",
+              parameters: [],
+              requestBody: {
+                content: {
+                  "application/json": {
+                    schema: {
+                      $ref: "#/components/schemas/TestBand"
+                    }
+                  }
+                },
+                required: false
+              },
+              responses: {
+                "200": {
+                  content: {
+                    "application/json": {
+                      schema: {
+                        $ref: "#/components/schemas/TestBand"
+                      }
+                    }
+                  },
+                  description: "Success"
+                }
+              },
+              tags: ["MyCtrl"]
+            }
+          }
+        },
+        tags: [
+          {
+            name: "MyCtrl"
+          }
+        ]
+      });
+    });
+  });
+
+  describe("with a given model as string ref", () => {
+    it("should set metadata and json schema", () => {
+      // WHEN
+      @Model()
+      class VirtualRefStringTestBand {
+        @VirtualRef({
+          ref: "VirtualRefStringTestPerson",
+          foreignField: "foreign",
+          localField: "test_2",
+          justOne: true,
+          count: false,
+          options: {}
+        })
+        member: VirtualRef<VirtualRefStringTestPerson>;
+
+        @VirtualRef({
+          ref: "VirtualRefStringTestPerson",
+          foreignField: "foreign",
+          localField: "test_2",
+          justOne: false,
+          count: false,
+          options: {}
+        })
+        members: VirtualRefStringTestPerson[];
+
+        @VirtualRef({
+          ref: "VirtualRefStringTestPerson",
+          foreignField: "foreign",
+          localField: "test_2",
+          count: true,
+          options: {}
+        })
+        memberCount: number;
+      }
+
+      @Model()
+      class VirtualRefStringTestPerson {
+        @Property()
+        name: string;
+
+        @Property()
+        band: string;
+      }
+
+      // THEN
+      const membersStore = Store.from(VirtualRefStringTestBand, "members");
+      const memberStore = Store.from(VirtualRefStringTestBand, "member");
+      const memberCount = Store.from(VirtualRefStringTestBand, "memberCount");
+
+      expect(memberStore.get(MONGOOSE_SCHEMA)).toEqual({
+        ref: "VirtualRefStringTestPerson",
+        localField: "test_2",
+        foreignField: "foreign",
+        justOne: true,
+        count: false,
+        options: {}
+      });
+
+      expect(membersStore.get(MONGOOSE_SCHEMA)).toEqual({
+        ref: "VirtualRefStringTestPerson",
+        localField: "test_2",
+        foreignField: "foreign",
+        justOne: false,
+        count: false,
+        options: {}
+      });
+
+      expect(memberCount.get(MONGOOSE_SCHEMA)).toEqual({
+        ref: "VirtualRefStringTestPerson",
+        localField: "test_2",
+        foreignField: "foreign",
+        justOne: false,
+        count: true,
+        options: {}
+      });
+
+      const schema = getJsonSchema(VirtualRefStringTestBand);
+
+      expect(schema).toEqual({
+        definitions: {
+          VirtualRefStringTestPerson: {
+            properties: {
+              band: {
+                type: "string"
+              },
+              name: {
+                type: "string"
+              }
+            },
+            type: "object"
+          }
+        },
+        properties: {
+          members: {
+            type: "array",
+            items: {
+              $ref: "#/definitions/VirtualRefStringTestPerson"
+            }
+          },
+          member: {
+            $ref: "#/definitions/VirtualRefStringTestPerson"
+          },
+          memberCount: {
+            type: "number"
+          }
+        },
+        type: "object"
+      });
+    });
+  });
+});

package/src/decorators/virtualRef.ts

@@ -0,0 +1,73 @@
+import {isPlainObject, isString, Store, StoreMerge, useDecorators} from "@tsed/core";
+import {CollectionOf, Property} from "@tsed/schema";
+
+import {MONGOOSE_MODEL_NAME, MONGOOSE_SCHEMA} from "../constants/constants.js";
+import {MongooseVirtualRefOptions} from "../interfaces/MongooseVirtualRefOptions.js";
+import {MongooseModels} from "../registries/MongooseModels.js";
+
+function getRef(opts: any) {
+  const ref = opts.ref;
+
+  return isString(ref) ? ref : Store.from(ref).get(MONGOOSE_MODEL_NAME);
+}
+
+function getType(opts: any) {
+  const ref = opts.ref;
+  return !isString(ref) ? ref : MongooseModels.get(ref) || (() => MongooseModels.get(ref) || Object);
+}
+
+function getInitialOpts(options: string | MongooseVirtualRefOptions, foreignField?: string): any {
+  return isPlainObject(options) ? options : {ref: options as any, foreignField};
+}
+
+function mapToSchema(opts: any) {
+  const ref = getRef(opts);
+
+  const schema: any = {
+    ref,
+    localField: opts.localField || "_id",
+    foreignField: opts.foreignField,
+    justOne: opts.justOne || false,
+    count: opts.count || false,
+    options: opts.options
+  };
+
+  return schema;
+}
+
+/**
+ * Define a property as mongoose virtual reference to other Model (decorated with @Model).
+ *
+ * ::: warning
+ * To avoid circular dependencies, do not use the virtual reference model in
+ * anything except a type declaration. Using the virtual reference model will prevent
+ * typescript transpiler from stripping away the import statement and cause a circular
+ * import in node.
+ * :::
+ *
+ * @param ref
+ * @param foreignField
+ * @returns {Function}
+ * @decorator
+ * @mongoose
+ * @property
+ */
+export function VirtualRef(ref: string, foreignField: string): Function;
+export function VirtualRef(options: MongooseVirtualRefOptions): Function;
+export function VirtualRef(options: string | MongooseVirtualRefOptions, foreignField?: string): Function;
+export function VirtualRef(options: string | MongooseVirtualRefOptions, foreignField?: string): Function {
+  const opts = getInitialOpts(options, foreignField);
+  const schema = mapToSchema(opts);
+  const type = getType(opts);
+
+  return useDecorators(
+    StoreMerge(MONGOOSE_SCHEMA, schema),
+    schema.count ? Property(Number) : type && (schema.justOne ? Property(type) : CollectionOf(type, Array))
+  );
+}
+
+export type VirtualRef<T> = T | null;
+/**
+ * @deprecated Use T[] instead
+ */
+export type VirtualRefs<T> = T[];

package/src/index.ts

@@ -0,0 +1,47 @@
+/**
+ * @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

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

package/src/interfaces/MongooseDocument.ts

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

package/src/interfaces/MongooseModel.ts

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

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

package/src/interfaces/MongooseSchemaOptions.ts

@@ -0,0 +1,51 @@
+import {type IndexOptions, Schema, SchemaOptions} from "mongoose";
+
+import {MongooseDocument} from "./MongooseDocument.js";
+
+export type MongooseNextCB = (err?: Error) => void;
+
+export interface MongooseHookOptions {
+  document?: boolean;
+  query?: boolean;
+  parallel?: boolean;
+}
+
+export type MongooseHookPromised<T = any> = (doc: T | MongooseDocument<T>) => Promise<void> | void;
+
+export type MongoosePreHookCB<T = any> = ((doc: T | MongooseDocument<T>, next: MongooseNextCB) => void) | MongooseHookPromised;
+
+export type MongoosePostHookCB<T = any> =
+  | ((doc: T | MongooseDocument<T>, error: Error, next: MongooseNextCB) => void)
+  | ((doc: T | MongooseDocument<T>, error: Error) => Promise<void> | void)
+  | ((doc: T | MongooseDocument<T>, next: MongooseNextCB) => void)
+  | MongooseHookPromised;
+
+export interface MongoosePreHook<T = any> {
+  method: string | RegExp;
+  fn: MongoosePreHookCB<T>;
+  options?: MongooseHookOptions;
+}
+
+export interface MongoosePostHook<T = any> {
+  method: string | RegExp;
+  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

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

package/src/interfaces/MongooseVirtualRefOptions.ts

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

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

package/src/registries/MongooseModels.ts

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

package/src/services/MongooseConnection.spec.ts

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