@tsed/mongoose 8.11.1 → 8.11.2-rc.1

package/src/decorators/mongoosePlugin.ts

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

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

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

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

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

@@ -1,44 +0,0 @@
-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("save", fn)
-      class Test {}
-
-      // THEN
-      const options = schemaOptions(Test);
-
-      expect(options).toEqual({
-        post: [
-          {
-            method: "save",
-            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

@@ -1,72 +0,0 @@
-import {decoratorTypeOf, DecoratorTypes, StaticMethodDecorator} from "@tsed/core";
-
-import {MongooseHookOptions, MongooseMethods, 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: MongooseMethods, fn: MongoosePostHookCB<T>): ClassDecorator;
-export function PostHook<T = any>(method: MongooseMethods, fn: MongoosePostHookCB<T>, options: MongooseHookOptions): ClassDecorator;
-export function PostHook<T = any>(method: MongooseMethods, options: MongooseHookOptions): StaticMethodDecorator;
-export function PostHook<T = any>(method: MongooseMethods, ...params: any[]): ClassDecorator | StaticMethodDecorator {
-  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;
-}

package/src/decorators/preHook.spec.ts

@@ -1,75 +0,0 @@
-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("save", fn as any, {query: true})
-      class Test {}
-
-      // THEN
-      const options = schemaOptions(Test);
-
-      expect(options).toEqual({
-        pre: [
-          {
-            method: "save",
-            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("save", fn, {query: true})
-      class Test {}
-
-      // THEN
-      const options = schemaOptions(Test);
-
-      expect(options).toEqual({
-        pre: [
-          {
-            method: "save",
-            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

@@ -1,79 +0,0 @@
-import {decoratorTypeOf, DecoratorTypes, StaticMethodDecorator} from "@tsed/core";
-
-import type {MongooseHookOptions, MongooseMethods, 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.
- *
- * @returns {Function}
- * @decorator
- * @class
- * @param method
- * @param fn
- * @param options
- */
-export function PreHook<T = any>(method: MongooseMethods, fn: MongoosePreHookCB<T>, options?: MongooseHookOptions): ClassDecorator;
-export function PreHook<T = any>(method: MongooseMethods, options?: MongooseHookOptions): StaticMethodDecorator;
-export function PreHook<T = any>(method: MongooseMethods, ...decoratorArgs: any[]): ClassDecorator | StaticMethodDecorator {
-  return (...args: any[]) => {
-    if (decoratorTypeOf(args) === DecoratorTypes.METHOD_STC) {
-      schemaOptions(args[0], {
-        pre: [
-          {
-            method,
-            fn: args[0][args[1]].bind(args[0]),
-            options: decoratorArgs[0]
-          }
-        ]
-      });
-    } else {
-      schemaOptions(args[0], {
-        pre: [
-          {
-            method,
-            fn: decoratorArgs[0],
-            options: decoratorArgs[1]
-          }
-        ]
-      });
-    }
-  };
-}