@tsed/mongoose 8.0.1 → 8.0.2

package/src/decorators/preHook.spec.ts

@@ -0,0 +1,75 @@
+import {MongooseNextCB, PreHook, schemaOptions} from "../../src/index.js";
+
+describe("@PreHook()", () => {
+  describe("when decorator is used as class decorator", () => {
+    it("should call applySchemaOptions", () => {
+      // GIVEN
+      const fn = vi.fn();
+
+      // WHEN
+      @PreHook("method", fn, {query: true})
+      class Test {}
+
+      // THEN
+      const options = schemaOptions(Test);
+
+      expect(options).toEqual({
+        pre: [
+          {
+            method: "method",
+            fn,
+            options: {
+              query: true
+            }
+          }
+        ]
+      });
+    });
+    it("should call applySchemaOptions with more options", () => {
+      // GIVEN
+      const fn: any = vi.fn((instance: any, next: MongooseNextCB, options: any) => {
+        return instance;
+      });
+
+      // WHEN
+      @PreHook("method", fn, {query: true})
+      class Test {}
+
+      // THEN
+      const options = schemaOptions(Test);
+
+      expect(options).toEqual({
+        pre: [
+          {
+            method: "method",
+            fn,
+            options: {
+              query: true
+            }
+          }
+        ]
+      });
+    });
+  });
+
+  describe("when decorator is used as method decorator", () => {
+    it("should call applySchemaOptions", () => {
+      class Test {
+        @PreHook("save", {
+          query: true
+        })
+        static method() {}
+      }
+
+      const {
+        pre: [options]
+      } = schemaOptions(Test);
+
+      expect(options.method).toBe("save");
+      expect(options.fn).toBeInstanceOf(Function);
+      expect(options.options).toEqual({
+        query: true
+      });
+    });
+  });
+});

package/src/decorators/preHook.ts

@@ -0,0 +1,70 @@
+import {decoratorTypeOf, DecoratorTypes} from "@tsed/core";
+
+import {MongooseHookOptions, MongoosePreHookCB} from "../interfaces/MongooseSchemaOptions.js";
+import {schemaOptions} from "../utils/schemaOptions.js";
+
+/**
+ *
+ * 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/platform-http";
+ * 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
+ */
+export function PreHook<T = any>(method: string, fn?: MongoosePreHookCB<T> | MongooseHookOptions, options?: MongooseHookOptions): Function {
+  return (...args: any[]) => {
+    if (decoratorTypeOf(args) === DecoratorTypes.METHOD_STC) {
+      options = fn as MongooseHookOptions;
+      fn = args[0][args[1]].bind(args[0]);
+    }
+
+    schemaOptions(args[0], {
+      pre: [
+        {
+          method,
+          fn: fn as MongoosePreHookCB<T>,
+          options
+        }
+      ]
+    });
+  };
+}

package/src/decorators/ref.spec.ts

@@ -0,0 +1,361 @@
+import {catchError, Store} from "@tsed/core";
+import {getJsonSchema, Property} from "@tsed/schema";
+import {Schema} from "mongoose";
+
+import {MONGOOSE_MODEL_NAME, MONGOOSE_SCHEMA} from "../constants/constants.js";
+import {MongooseModels} from "../registries/MongooseModels.js";
+import {Ref} from "./ref.js";
+
+describe("@Ref()", () => {
+  describe("type is a class", () => {
+    it("should set metadata and catch error", () => {
+      const error = catchError(() => {
+        class Model {
+          @Ref(undefined)
+          num: number[];
+        }
+      });
+
+      expect(error?.message).toEqual(
+        "A model is required on `@Ref(model)` decorator. Please give a model or wrap it inside an arrow function if you have a circular reference."
+      );
+    });
+
+    it("should set metadata", () => {
+      class RefTest {
+        @Property()
+        id: string;
+      }
+
+      Store.from(RefTest).set(MONGOOSE_MODEL_NAME, "RefTest");
+
+      class Test {
+        @Ref(RefTest)
+        test: Ref<RefTest>;
+      }
+
+      const store = Store.from(Test, "test");
+      const schema = getJsonSchema(Test);
+
+      expect(schema).toEqual({
+        definitions: {
+          RefTest: {
+            type: "object",
+            properties: {
+              id: {
+                type: "string"
+              }
+            }
+          }
+        },
+        properties: {
+          test: {
+            oneOf: [
+              {
+                description: "A reference ObjectID",
+                examples: ["5ce7ad3028890bd71749d477"],
+                type: "string"
+              },
+              {
+                $ref: "#/definitions/RefTest"
+              }
+            ]
+          }
+        },
+        type: "object"
+      });
+
+      expect(store.get(MONGOOSE_SCHEMA)).toEqual({
+        type: Schema.Types.ObjectId,
+        ref: RefTest
+      });
+    });
+  });
+  describe("type is a map of class", () => {
+    it("should set metadata", () => {
+      class RefTest {
+        @Property()
+        id: string;
+      }
+
+      Store.from(RefTest).set(MONGOOSE_MODEL_NAME, "RefTest");
+      MongooseModels.set("RefTest", RefTest);
+
+      class Test {
+        @Ref(RefTest)
+        test: Map<string, Ref<RefTest>>;
+      }
+
+      const store = Store.from(Test, "test");
+      const schema = getJsonSchema(Test);
+
+      expect(schema).toEqual({
+        definitions: {
+          RefTest: {
+            properties: {
+              id: {
+                type: "string"
+              }
+            },
+            type: "object"
+          }
+        },
+        properties: {
+          test: {
+            additionalProperties: {
+              oneOf: [
+                {
+                  description: "A reference ObjectID",
+                  examples: ["5ce7ad3028890bd71749d477"],
+                  type: "string"
+                },
+                {
+                  $ref: "#/definitions/RefTest"
+                }
+              ]
+            },
+            type: "object"
+          }
+        },
+        type: "object"
+      });
+
+      expect(store.get(MONGOOSE_SCHEMA)).toEqual({
+        type: Schema.Types.ObjectId,
+        ref: RefTest
+      });
+    });
+  });
+  describe("type is a Function", () => {
+    it("should set metadata", () => {
+      class RefTest {
+        @Property()
+        id: string;
+      }
+
+      Store.from(RefTest).set(MONGOOSE_MODEL_NAME, "RefTest");
+      const arrow = () => RefTest;
+
+      class Test {
+        @Ref(arrow)
+        test: Ref<RefTest>;
+      }
+
+      const store = Store.from(Test, "test");
+      const schema = getJsonSchema(Test);
+
+      expect(schema).toEqual({
+        definitions: {
+          RefTest: {
+            type: "object",
+            properties: {
+              id: {
+                type: "string"
+              }
+            }
+          }
+        },
+        properties: {
+          test: {
+            oneOf: [
+              {
+                description: "A reference ObjectID",
+                examples: ["5ce7ad3028890bd71749d477"],
+                type: "string"
+              },
+              {
+                $ref: "#/definitions/RefTest"
+              }
+            ]
+          }
+        },
+        type: "object"
+      });
+
+      expect(store.get(MONGOOSE_SCHEMA)).toEqual({
+        type: Schema.Types.ObjectId,
+        ref: arrow
+      });
+    });
+  });
+  describe("type is a string (deprecated)", () => {
+    it("should set metadata", () => {
+      class RefTest {}
+
+      class Test {
+        @Ref("RefTest")
+        test: Ref<RefTest>;
+      }
+
+      MongooseModels.set("RefTest", RefTest);
+      const store = Store.from(Test, "test");
+
+      expect(getJsonSchema(Test)).toEqual({
+        definitions: {
+          RefTest: {
+            properties: {
+              id: {
+                type: "string"
+              }
+            },
+            type: "object"
+          }
+        },
+        properties: {
+          test: {
+            oneOf: [
+              {
+                description: "A reference ObjectID",
+                examples: ["5ce7ad3028890bd71749d477"],
+                type: "string"
+              },
+              {
+                $ref: "#/definitions/RefTest"
+              }
+            ]
+          }
+        },
+        type: "object"
+      });
+      expect(store.get(MONGOOSE_SCHEMA)).toEqual({
+        type: Schema.Types.ObjectId,
+        ref: "RefTest"
+      });
+    });
+  });
+  describe("JsonSchema gets generated based on populated groups", () => {
+    class MyChildModel {
+      @Property()
+      test: string;
+    }
+
+    class MyParentModel {
+      @Property()
+      id: string;
+
+      @Ref(MyChildModel, {populatedGroups: ["group1", "group2"]})
+      child1: Ref<MyChildModel>;
+
+      @Ref(MyChildModel, {populatedGroups: ["group2"]})
+      child2: Ref<MyChildModel>;
+
+      @Ref(MyChildModel)
+      child3: Ref<MyChildModel>;
+    }
+
+    it("should reflect the populated groups options in the schema (with given groups)", () => {
+      const spec = getJsonSchema(MyParentModel, {
+        groups: ["group1", "group3"]
+      });
+
+      expect(spec).toEqual({
+        definitions: {
+          MyChildModel: {
+            properties: {
+              test: {
+                type: "string"
+              }
+            },
+            type: "object"
+          },
+          MyChildModelGroup1Group3: {
+            properties: {
+              test: {
+                type: "string"
+              }
+            },
+            type: "object"
+          }
+        },
+        properties: {
+          child1: {
+            oneOf: [
+              {
+                $ref: "#/definitions/MyChildModelGroup1Group3"
+              }
+            ]
+          },
+          child2: {
+            oneOf: [
+              {
+                description: "A reference ObjectID",
+                examples: ["5ce7ad3028890bd71749d477"],
+                type: "string"
+              }
+            ]
+          },
+          child3: {
+            oneOf: [
+              {
+                description: "A reference ObjectID",
+                examples: ["5ce7ad3028890bd71749d477"],
+                type: "string"
+              },
+              {
+                $ref: "#/definitions/MyChildModel"
+              }
+            ]
+          },
+          id: {
+            type: "string"
+          }
+        },
+        type: "object"
+      });
+    });
+
+    it("should reflect the populated groups options in the schema (without given groups)", () => {
+      const spec = getJsonSchema(MyParentModel, {
+        groups: []
+      });
+      expect(spec).toEqual({
+        definitions: {
+          MyChildModel: {
+            properties: {
+              test: {
+                type: "string"
+              }
+            },
+            type: "object"
+          }
+        },
+        properties: {
+          child1: {
+            oneOf: [
+              {
+                description: "A reference ObjectID",
+                examples: ["5ce7ad3028890bd71749d477"],
+                type: "string"
+              }
+            ]
+          },
+          child2: {
+            oneOf: [
+              {
+                description: "A reference ObjectID",
+                examples: ["5ce7ad3028890bd71749d477"],
+                type: "string"
+              }
+            ]
+          },
+          child3: {
+            oneOf: [
+              {
+                description: "A reference ObjectID",
+                examples: ["5ce7ad3028890bd71749d477"],
+                type: "string"
+              },
+              {
+                $ref: "#/definitions/MyChildModel"
+              }
+            ]
+          },
+          id: {
+            type: "string"
+          }
+        },
+        type: "object"
+      });
+    });
+  });
+});

package/src/decorators/ref.ts

@@ -0,0 +1,111 @@
+import {isArrowFn, isCollection, isObject, isObjectID, isString, StoreMerge, Type, useDecorators} from "@tsed/core";
+import {deserialize, OnDeserialize, OnSerialize, serialize} from "@tsed/json-mapper";
+import {ForwardGroups, JsonEntityFn, lazyRef, matchGroups, OneOf, Property, string} from "@tsed/schema";
+import {Schema as MongooseSchema} from "mongoose";
+
+import {MONGOOSE_SCHEMA} from "../constants/constants.js";
+import {MongooseSchemaTypes} from "../interfaces/MongooseSchemaTypes.js";
+import {MongooseModels} from "../registries/MongooseModels.js";
+
+interface RefOptions {
+  type?: MongooseSchemaTypes;
+  populatedGroups?: string[];
+}
+
+function isRef(value: undefined | string | any) {
+  return isObjectID(value) || isString(value);
+}
+
+function PopulateGroups(populatedGroups: string[]) {
+  return useDecorators(
+    ForwardGroups(true),
+    JsonEntityFn((store) => {
+      store.schema.$hooks.on("oneOf", (obj: any[], givenGroups: string[]) => {
+        if (matchGroups(populatedGroups, givenGroups)) {
+          return obj.filter((x) => x.type === "string"); // keep the object id;
+        } else {
+          return obj.filter((x) => x.type !== "string"); // keep the ref definition
+        }
+      });
+    })
+  );
+}
+
+/**
+ * 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 options
+ * @returns {Function}
+ * @decorator
+ * @mongoose
+ * @property
+ */
+export function Ref(
+  model: string | (() => Type) | any,
+  options: RefOptions | MongooseSchemaTypes = MongooseSchemaTypes.OBJECT_ID
+): PropertyDecorator {
+  if (!model) {
+    throw new Error(
+      "A model is required on `@Ref(model)` decorator. Please give a model or wrap it inside an arrow function if you have a circular reference."
+    );
+  }
+
+  const getType = () => (isString(model) ? MongooseModels.get(model) : isArrowFn(model) ? model() : model);
+  const populatedGroups = (isObject(options) && options.populatedGroups) || [];
+
+  return useDecorators(
+    Property(Object),
+    StoreMerge(MONGOOSE_SCHEMA, {
+      type: MongooseSchema.Types[isObject(options) ? options.type || MongooseSchemaTypes.OBJECT_ID : options],
+      ref: model
+    }),
+    OnDeserialize((value) => {
+      if (isRef(value)) {
+        return value.toString();
+      }
+
+      if (isCollection(value) && isRef(value[0])) {
+        return value.map(String);
+      }
+
+      return deserialize(value, {type: getType(), useAlias: false});
+    }),
+    OnSerialize((value: any, ctx) => {
+      if (isRef(value)) {
+        return value.toString();
+      }
+
+      if (isCollection(value) && isRef(value[0])) {
+        return value.map(String);
+      }
+
+      const type = getType();
+
+      return serialize(value, {...ctx, type});
+    }),
+    OneOf(string().example("5ce7ad3028890bd71749d477").description("A reference ObjectID"), lazyRef(getType)),
+    populatedGroups.length && PopulateGroups(populatedGroups)
+  ) as PropertyDecorator;
+}
+
+export type Ref<T> = T | string;

package/src/decorators/schema.ts

@@ -0,0 +1,79 @@
+import {decoratorTypeOf, StoreMerge, useDecorators} from "@tsed/core";
+import {injectable} from "@tsed/di";
+import {Property} from "@tsed/schema";
+import {SchemaTypeOptions} from "mongoose";
+
+import {MONGOOSE_SCHEMA} from "../constants/constants.js";
+import {MongooseSchemaOptions} from "../interfaces/MongooseSchemaOptions.js";
+import {getSchema, getSchemaToken} from "../utils/createSchema.js";
+
+/**
+ * Define a class as a Mongoose Schema ready to be used to compose other schemes and models.
+ *
+ * ### Example
+ *
+ * ```typescript
+ * @MongooseSchema()
+ * export class EventSchema {
+ *   @Property()
+ *   field: string;
+ * }
+ * ```
+ *
+ * ### Options
+ *
+ * - `schemaOptions` (mongoose.SchemaOptions): Option to configure the schema behavior.
+ *
+ * @param {MongooseSchemaOptions | undefined} options
+ * @returns {(target: any) => void}
+ * @decorator
+ * @mongoose
+ * @property
+ * @class
+ */
+export function Schema(options?: MongooseSchemaOptions): (target: any) => void;
+export function Schema(definition: SchemaTypeOptions<any>): Function;
+export function Schema(options: MongooseSchemaOptions | SchemaTypeOptions<any> = {}) {
+  return (...parameters: any[]) => {
+    switch (decoratorTypeOf(parameters)) {
+      case "property":
+        return useDecorators(Property(), StoreMerge(MONGOOSE_SCHEMA, options))(parameters[0], parameters[1], parameters[2]);
+
+      case "class":
+        const {token} = getSchemaToken(parameters[0], options);
+
+        injectable(token).factory(() => getSchema(parameters[0], options as any));
+        break;
+    }
+  };
+}
+
+/**
+ * Define a class as a Mongoose Schema ready to be used to compose other schemes and models.
+ *
+ * ### Example
+ *
+ * ```typescript
+ * @MongooseSchema()
+ * export class EventSchema {
+ *   @Property()
+ *   field: string;
+ * }
+ * ```
+ *
+ * ### Options
+ *
+ * - `schemaOptions` (mongoose.SchemaOptions): Option to configure the schema behavior.
+ *
+ * @param {MongooseSchemaOptions | undefined} options
+ * @returns {(target: any) => void}
+ * @decorator
+ * @mongoose
+ * @property
+ * @class
+ */
+export function MongooseSchema(options?: MongooseSchemaOptions): (target: any) => void;
+export function MongooseSchema(definition: SchemaTypeOptions<any>): Function;
+export function MongooseSchema(options: MongooseSchemaOptions | SchemaTypeOptions<any> = {}) {
+  return Schema(options as any);
+}

package/src/decorators/schemaIgnore.spec.ts

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