@tsed/mongoose 8.0.1 → 8.0.2

package/src/decorators/mongooseIndexes.spec.ts

@@ -0,0 +1,35 @@
+import {schemaOptions} from "../utils/schemaOptions.js";
+import {MongooseIndexes} from "./mongooseIndexes.js";
+
+describe("@MongooseIndexes()", () => {
+  class Test {}
+
+  it("should store options", () => {
+    // WHEN
+    @MongooseIndexes([
+      {fields: {field: "1"}, options: {}},
+      {fields: {field2: "1"}, options: {}}
+    ])
+    class Test {}
+
+    // THEN
+    const options = schemaOptions(Test);
+
+    expect(options).toEqual({
+      indexes: [
+        {
+          fields: {
+            field: "1"
+          },
+          options: {}
+        },
+        {
+          fields: {
+            field2: "1"
+          },
+          options: {}
+        }
+      ]
+    });
+  });
+});

package/src/decorators/mongooseIndexes.ts

@@ -0,0 +1,35 @@
+import {schemaOptions} from "../utils/schemaOptions.js";
+
+/**
+ * Calls schema.index() to define multiple indexes (most likely compound) for the schema.
+ *
+ * ### Example
+ *
+ * ```typescript
+ * @Model()
+ * @MongooseIndexes([{fields: {first: 1, second: 1}, options:{unique: 1}}, {fields: {first: 1, third: 1}, options:{unique: 1}}])
+ * export class EventModel {
+ *
+ *   @Property()
+ *   first: string;
+ *
+ *   @Property()
+ *   second: string;
+ *
+ *   @Property()
+ *   third: string;
+ *
+ * }
+ * ```
+ *
+ * @param indexes - define multiple mongoose indexes
+ * @returns {Function}
+ * @decorator
+ * @mongoose
+ * @class
+ */
+export function MongooseIndexes(indexes: Array<{fields: object; options?: any}>): Function {
+  return (target: any) => {
+    schemaOptions(target, {indexes});
+  };
+}

package/src/decorators/mongoosePlugin.spec.ts

@@ -0,0 +1,25 @@
+import {MongoosePlugin} from "../../src/decorators/mongoosePlugin.js";
+import {schemaOptions} from "../../src/utils/schemaOptions.js";
+
+describe("@MongoosePlugin()", () => {
+  it("should store options", () => {
+    // GIVEN
+    const fn = vi.fn();
+
+    // WHEN
+    @MongoosePlugin(fn, {})
+    class Test {}
+
+    // THEN
+    const options = schemaOptions(Test);
+
+    expect(options).toEqual({
+      plugins: [
+        {
+          plugin: fn,
+          options: {}
+        }
+      ]
+    });
+  });
+});

package/src/decorators/mongoosePlugin.ts

@@ -0,0 +1,20 @@
+import mongoose from "mongoose";
+
+import {schemaOptions} from "../utils/schemaOptions.js";
+
+/**
+ *
+ * @param {(schema: "mongoose".Schema, options?: any) => void} plugin
+ * @param options
+ * @returns {Function}
+ * @decorator
+ * @mongoose
+ * @class
+ */
+export function MongoosePlugin(plugin: (schema: mongoose.Schema, options?: any) => void, options?: any): Function {
+  return (target: any) => {
+    schemaOptions(target, {
+      plugins: [{plugin, options}]
+    });
+  };
+}

package/src/decorators/numberDecimal.spec.ts

@@ -0,0 +1,266 @@
+import {Store} from "@tsed/core";
+import {deserialize, serialize} from "@tsed/json-mapper";
+import {getJsonSchema} from "@tsed/schema";
+import {Schema, Types} from "mongoose";
+
+import {MONGOOSE_SCHEMA} from "../constants/constants.js";
+import {Decimal128, DecimalFormat, NumberDecimal} from "./numberDecimal.js";
+
+describe("@NumberDecimal()", () => {
+  it("should declare a Decimal128 field", () => {
+    // WHEN
+    class Test {
+      @NumberDecimal()
+      price: Decimal128;
+    }
+
+    // THEN
+    const store = Store.from(Test, "price");
+    const schema = getJsonSchema(Test);
+
+    expect(schema).toEqual({
+      properties: {
+        price: {
+          examples: [12.34],
+          type: "number",
+          format: "decimal"
+        }
+      },
+      type: "object"
+    });
+
+    expect(store.get(MONGOOSE_SCHEMA)).toEqual({
+      type: Schema.Types.Decimal128
+    });
+  });
+  it("should declare a decimal number format", () => {
+    // WHEN
+    const format = new DecimalFormat();
+    const validate: (value: any) => boolean = format.validate;
+
+    // THEN
+    const store = Store.from(DecimalFormat);
+
+    expect(store.get("ajv:formats")).toEqual({
+      name: "decimal",
+      options: {
+        type: "number"
+      }
+    });
+
+    expect(validate(undefined)).toBe(false);
+    expect(validate(null)).toBe(false);
+    expect(validate([])).toBe(false);
+    expect(validate({})).toBe(false);
+    expect(validate("0.0")).toBe(true);
+    expect(validate(NaN)).toBe(true);
+    expect(validate(0)).toBe(true);
+  });
+  it("should deserialize a number value", () => {
+    // WHEN
+    class Model {
+      @NumberDecimal()
+      price: Decimal128;
+    }
+
+    // THEN
+    const result = deserialize(
+      {
+        price: 1234.56
+      },
+      {type: Model, additionalProperties: false}
+    );
+
+    expect(result).toBeInstanceOf(Model);
+    expect(result).toEqual({
+      price: Types.Decimal128.fromString("1234.56")
+    });
+  });
+  it("should deserialize a string value", () => {
+    // WHEN
+    class Model {
+      @NumberDecimal()
+      price: Decimal128;
+    }
+
+    // THEN
+    const result = deserialize(
+      {
+        price: "1234.56"
+      },
+      {type: Model, additionalProperties: false}
+    );
+
+    expect(result).toBeInstanceOf(Model);
+    expect(result).toEqual({
+      price: Types.Decimal128.fromString("1234.56")
+    });
+  });
+  it("should serialize a number value", () => {
+    // WHEN
+    class Model {
+      @NumberDecimal()
+      price: Decimal128;
+    }
+
+    const mdl = new Model();
+    mdl.price = Types.Decimal128.fromString("1234.56");
+
+    // THEN
+    const result = serialize(mdl);
+
+    expect(result).toEqual({
+      price: 1234.56
+    });
+  });
+  it("should serialize an undefined value", () => {
+    // WHEN
+    class Model {
+      @NumberDecimal()
+      price?: Decimal128;
+    }
+
+    const mdl = new Model();
+
+    // THEN
+    const result = serialize(mdl);
+
+    expect(result).not.toHaveProperty("price");
+  });
+  it("should deserialize an undefined value", () => {
+    // WHEN
+    class Model {
+      @NumberDecimal()
+      price?: Decimal128;
+    }
+
+    // THEN
+    const result = deserialize({}, {type: Model, additionalProperties: false});
+
+    expect(result).toBeInstanceOf(Model);
+    expect(result.price).toEqual(undefined);
+  });
+  it("should deserialize a number value using custom decimal", () => {
+    // GIVEN
+    class Decimal {
+      constructor(private value: any) {}
+      toString() {
+        return `${this.value}`;
+      }
+    }
+
+    const fakePrice = new Decimal("1234.56");
+
+    const obj = {Decimal};
+    vi.spyOn(obj, "Decimal").mockReturnValue(fakePrice);
+
+    // WHEN
+    class Model {
+      @NumberDecimal(obj.Decimal)
+      price: Decimal;
+    }
+
+    // THEN
+    const result = deserialize(
+      {
+        price: "1234.56"
+      },
+      {type: Model, additionalProperties: false}
+    );
+
+    expect(obj.Decimal).toHaveBeenCalledWith("1234.56");
+
+    expect(result).toBeInstanceOf(Model);
+    expect(result).toEqual({
+      price: fakePrice
+    });
+  });
+  it("should serialize a number value using custom decimal", () => {
+    // GIVEN
+    class Decimal {
+      constructor(private value: any) {}
+      toString() {
+        return `${this.value}`;
+      }
+    }
+
+    // WHEN
+    class Model {
+      @NumberDecimal(Decimal)
+      price: Decimal;
+    }
+
+    const mdl = new Model();
+    mdl.price = new Decimal("1234.56");
+
+    // THEN
+    const result = serialize(mdl);
+
+    expect(result).toEqual({
+      price: 1234.56
+    });
+  });
+  it("should convert Decimal128 to custom implementation", () => {
+    // GIVEN
+    class Decimal {
+      constructor(private value: any) {}
+      toString() {
+        return `${this.value}`;
+      }
+    }
+
+    const testDecimal = Types.Decimal128.fromString("1234.56");
+    const fakePrice = new Decimal("1234.56");
+
+    const obj = {Decimal};
+    vi.spyOn(obj, "Decimal").mockReturnValue(fakePrice);
+
+    // WHEN
+    class Model {
+      @NumberDecimal(obj.Decimal)
+      price: Decimal;
+    }
+
+    const mdl = new Model();
+    mdl.price = new Decimal("1234.56");
+
+    // THEN
+    const store = Store.from(Model, "price");
+    const schema = store.get(MONGOOSE_SCHEMA);
+
+    expect(schema.get).toBeInstanceOf(Function);
+    expect(schema.get(testDecimal)).toBe(fakePrice);
+    expect(obj.Decimal).toHaveBeenCalledWith(testDecimal);
+  });
+  it("should not convert custom decimal again", () => {
+    // GIVEN
+    class Decimal {
+      constructor(private value: any) {}
+      toString() {
+        return `${this.value}`;
+      }
+    }
+
+    const fakePrice = new Decimal("1234.56");
+
+    const obj = {Decimal};
+    vi.spyOn(obj, "Decimal").mockReturnValue(fakePrice);
+
+    // WHEN
+    class Model {
+      @NumberDecimal(obj.Decimal)
+      price: Decimal;
+    }
+
+    const mdl = new Model();
+    mdl.price = new Decimal("1234.56");
+
+    // THEN
+    const store = Store.from(Model, "price");
+    const schema = store.get(MONGOOSE_SCHEMA);
+
+    expect(schema.get).toBeInstanceOf(Function);
+    expect(schema.get(fakePrice)).toBe(fakePrice);
+    expect(obj.Decimal).not.toHaveBeenCalled();
+  });
+});

package/src/decorators/numberDecimal.ts

@@ -0,0 +1,84 @@
+import {Formats, FormatsMethods} from "@tsed/ajv";
+import {isNumber, isString, StoreMerge, useDecorators} from "@tsed/core";
+import {OnDeserialize, OnSerialize} from "@tsed/json-mapper";
+import {Example, Format, Property} from "@tsed/schema";
+import {Schema as MongooseSchema, SchemaTypeOptions, Types} from "mongoose";
+
+import {MONGOOSE_SCHEMA} from "../constants/constants.js";
+
+@Formats("decimal", {type: "number"})
+export class DecimalFormat implements FormatsMethods<string | number> {
+  validate(num: string | number): boolean {
+    return isString(num) || isNumber(num);
+  }
+}
+
+function isDecimal(value: undefined | number | any) {
+  return value && value._bsontype === "Decimal128";
+}
+
+/**
+ * Tell Mongoose whether to define an Decimal128 property.
+ * Will be serialized as `number` with format as `decimal`.
+ * ### Example
+ *
+ * ```typescript
+ * @Model()
+ * export class PriceModel {
+ *   @NumberDecimal()
+ *   price: Decimal128;
+ * }
+ * ```
+ * Optionally using custom decimal type, such as `Big` from big.js
+ * ```typescript
+ * @Model()
+ * export class PriceModel {
+ *   @NumberDecimal(Big)
+ *   price: Big;
+ * }
+ * ```
+ * @param type Optional decimal type constructor
+ * @decorator
+ * @mongoose
+ * @schema
+ */
+export function NumberDecimal(type?: any) {
+  const schema: SchemaTypeOptions<Decimal128> = {
+    type: MongooseSchema.Types.Decimal128
+  };
+
+  if (type) {
+    // Define property getter to convert Decimal128 to custom type
+    schema.get = (value) => {
+      return isDecimal(value) ? new type(value) : value;
+    };
+  }
+
+  return useDecorators(
+    Property(Number),
+    Format("decimal"),
+    Example(12.34),
+    StoreMerge(MONGOOSE_SCHEMA, schema),
+
+    // Deserialize number value from JSON to Decimal128
+    OnDeserialize((value) => {
+      if (value === undefined) {
+        return undefined;
+      }
+      if (type) {
+        return new type(value);
+      }
+      if (isString(value)) {
+        return Types.Decimal128.fromString(value);
+      }
+      return Types.Decimal128.fromString(`${value}`);
+    }),
+
+    // Serialize decimal value to floating point number
+    OnSerialize((value: any, ctx) => {
+      return value && Number(value);
+    })
+  );
+}
+
+export type Decimal128 = Types.Decimal128;

package/src/decorators/objectID.spec.ts

@@ -0,0 +1,24 @@
+import {getJsonSchema} from "@tsed/schema";
+
+import {ObjectID} from "./objectID.js";
+
+describe("ObjectID", () => {
+  it("should declare an ObjectID field", () => {
+    class MyModelTest {
+      @ObjectID("id")
+      _id: string;
+    }
+
+    expect(getJsonSchema(MyModelTest)).toEqual({
+      properties: {
+        id: {
+          description: "An ObjectID",
+          examples: ["5ce7ad3028890bd71749d477"],
+          pattern: "^[0-9a-fA-F]{24}$",
+          type: "string"
+        }
+      },
+      type: "object"
+    });
+  });
+});

package/src/decorators/objectID.ts

@@ -0,0 +1,39 @@
+import {useDecorators} from "@tsed/core";
+import {OnDeserialize} from "@tsed/json-mapper";
+import {Description, Example, Name, Pattern} from "@tsed/schema";
+import {Types} from "mongoose";
+
+import {Auto} from "./auto.js";
+import {Schema} from "./schema.js";
+
+/**
+ * Tell Mongoose whether to define an ObjectId property.
+ * ### Example
+ *
+ * ```typescript
+ * @Model()
+ * export class EventModel {
+ *   @ObjectId('id')
+ *   _id: string;
+ * }
+ * ```
+ * @param name
+ * @decorator
+ * @mongoose
+ * @schema
+ */
+export function ObjectID(name?: string) {
+  return useDecorators(
+    name && Name(name),
+    Pattern(/^[0-9a-fA-F]{24}$/),
+    Description("An ObjectID"),
+    Example("5ce7ad3028890bd71749d477"),
+    Auto(),
+    Schema({
+      type: Types.ObjectId,
+      match: undefined
+    })
+  );
+}
+
+export type ObjectID = Types.ObjectId;

package/src/decorators/postHook.spec.ts

@@ -0,0 +1,44 @@
+import {schemaOptions} from "../utils/schemaOptions.js";
+import {PostHook} from "./postHook.js";
+
+describe("@PostHook()", () => {
+  describe("when decorator is used as class decorator", () => {
+    it("should call applySchemaOptions", () => {
+      // GIVEN
+      const fn = vi.fn();
+
+      // WHEN
+      @PostHook("method", fn)
+      class Test {}
+
+      // THEN
+      const options = schemaOptions(Test);
+
+      expect(options).toEqual({
+        post: [
+          {
+            method: "method",
+            fn,
+            options: undefined
+          }
+        ]
+      });
+    });
+  });
+
+  describe("when decorator is used as method decorator", () => {
+    it("should call applySchemaOptions", () => {
+      class Test {
+        @PostHook("save", {})
+        static method() {}
+      }
+
+      const {
+        post: [options]
+      } = schemaOptions(Test);
+
+      expect(options.method).toEqual("save");
+      expect(options.fn).toBeInstanceOf(Function);
+    });
+  });
+});

package/src/decorators/postHook.ts

@@ -0,0 +1,72 @@
+import {decoratorTypeOf, DecoratorTypes, StaticMethodDecorator} from "@tsed/core";
+
+import {MongooseHookOptions, MongoosePostHookCB} from "../interfaces/MongooseSchemaOptions.js";
+import {schemaOptions} from "../utils/schemaOptions.js";
+
+/**
+ * We can simply attach a `@PostHook` 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 {PostHook, Model} from "@tsed/mongoose";
+ *
+ * @Model()
+ * @PostHook("save", (car: CarModel) => {
+ *    if (car.topSpeedInKmH > 300) {
+ *        console.log(car.model, 'is fast!');
+ *    }
+ * })
+ * export class CarModel {
+ *    @Ignore()
+ *    _id: string;
+ *
+ *    @Required()
+ *    model: string;
+ *
+ *    @Required()
+ *    isFast: boolean;
+ *
+ *    // or Prehook on static method
+ *    @PostHook("save")
+ *    static postSave(car: CarModel) {
+ *       if (car.topSpeedInKmH > 300) {
+ *           console.log(car.model, 'is fast!');
+ *       }
+ *    }
+ * }
+ * ```
+ *
+ * This will execute the post-save hook each time a `CarModel` document is saved.
+ *
+ * @param {string} method
+ * @param fn
+ * @returns {Function}
+ * @decorator
+ * @mongoose
+ * @class
+ */
+export function PostHook<T = any>(method: string, fn: MongoosePostHookCB<T>): ClassDecorator;
+export function PostHook<T = any>(method: string, fn: MongoosePostHookCB<T>, options: MongooseHookOptions): ClassDecorator;
+export function PostHook<T = any>(method: string, options: MongooseHookOptions): StaticMethodDecorator;
+export function PostHook<T = any>(method: string, ...params: any[]): Function {
+  return ((...args: any[]) => {
+    let options: MongooseHookOptions = params[1];
+    let fn: MongoosePostHookCB<T> = params[0];
+
+    if (decoratorTypeOf(args) === DecoratorTypes.METHOD_STC) {
+      options = params[0];
+      fn = args[0][args[1]].bind(args[0]);
+    }
+
+    schemaOptions(args[0], {
+      post: [
+        {
+          method,
+          fn,
+          options
+        }
+      ]
+    });
+  }) as any;
+}