@tsed/mongoose 8.11.1 → 8.11.2-rc.1

package/src/decorators/text.spec.ts

@@ -1,30 +0,0 @@
-import {descriptorOf, Store} from "@tsed/core";
-
-import {MONGOOSE_SCHEMA} from "../constants/constants.js";
-import {Text} from "./text.js";
-
-describe("@Text()", () => {
-  it("should set metadata (default)", () => {
-    class Test {
-      @Text()
-      test: string;
-    }
-
-    const store = Store.from(Test, "test", descriptorOf(Test, "test"));
-    expect(store.get(MONGOOSE_SCHEMA)).toEqual({
-      text: true
-    });
-  });
-
-  it("should set metadata (true)", () => {
-    class Test {
-      @Text(true)
-      test: string;
-    }
-
-    const store = Store.from(Test, "test", descriptorOf(Test, "test"));
-    expect(store.get(MONGOOSE_SCHEMA)).toEqual({
-      text: true
-    });
-  });
-});

package/src/decorators/text.ts

@@ -1,25 +0,0 @@
-import {MongooseSchema} from "./schema.js";
-
-/**
- * If [truthy](https://masteringjs.io/tutorials/fundamentals/truthy), Mongoose
- * will build a text index on this path.
- *
- * ### Example
- *
- * ```typescript
- * @Model()
- * export class EventModel {
- *   @Text()
- *   field: string;
- * }
- * ```
- *
- * @param {boolean | number | any} text
- * @returns {Function}
- * @decorator
- * @mongoose
- * @property
- */
-export function Text(text: boolean | number | any = true): PropertyDecorator {
-  return MongooseSchema({text} as any);
-}

package/src/decorators/trim.spec.ts

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

package/src/decorators/trim.ts

@@ -1,23 +0,0 @@
-import {MongooseSchema} from "./schema.js";
-
-/**
- * Tell Mongoose to make the property trimmable.
- *
- * ### Example
- *
- * ```typescript
- * @Model()
- * export class EventModel {
- *   @Trim()
- *   name: string;
- * }
- * ```
- *
- * @returns {Function}
- * @decorator
- * @mongoose
- * @property
- */
-export function Trim() {
-  return MongooseSchema({trim: true});
-}

package/src/decorators/unique.spec.ts

@@ -1,18 +0,0 @@
-import {Store} from "@tsed/core";
-
-import {Unique} from "../../src/index.js";
-import {MONGOOSE_SCHEMA} from "../constants/constants.js";
-
-describe("@Unique()", () => {
-  it("should set metadata", () => {
-    class Test {
-      @Unique()
-      id: string;
-    }
-
-    const store = Store.from(Test, "id");
-    expect(store.get(MONGOOSE_SCHEMA)).toEqual({
-      unique: true
-    });
-  });
-});

package/src/decorators/unique.ts

@@ -1,23 +0,0 @@
-import {MongooseSchema} from "./schema.js";
-
-/**
- * Tell Mongoose to ensure a unique index is created for this path.
- *
- * ### Example
- *
- * ```typescript
- * @Model()
- * export class EventModel {
- *   @Unique()
- *   index: string;
- * }
- * ```
- *
- * @param {boolean | any} unique
- * @returns {Function}
- * @decorator
- * @mongoose
- */
-export function Unique(unique: boolean | any = true) {
-  return MongooseSchema({unique});
-}

package/src/decorators/uppercase.spec.ts

@@ -1,30 +0,0 @@
-import {descriptorOf, Store} from "@tsed/core";
-
-import {MONGOOSE_SCHEMA} from "../constants/constants.js";
-import {Uppercase} from "./uppercase.js";
-
-describe("@Uppercase()", () => {
-  it("should set metadata (default)", () => {
-    class Test {
-      @Uppercase()
-      test: string;
-    }
-
-    const store = Store.from(Test, "test", descriptorOf(Test, "test"));
-    expect(store.get(MONGOOSE_SCHEMA)).toEqual({
-      uppercase: true
-    });
-  });
-
-  it("should set metadata (true)", () => {
-    class Test {
-      @Uppercase(true)
-      test: string;
-    }
-
-    const store = Store.from(Test, "test", descriptorOf(Test, "test"));
-    expect(store.get(MONGOOSE_SCHEMA)).toEqual({
-      uppercase: true
-    });
-  });
-});

package/src/decorators/uppercase.ts

@@ -1,24 +0,0 @@
-import {MongooseSchema} from "./schema.js";
-
-/**
- * If truthy, Mongoose will add a custom setter that uppercases this string using JavaScript's built-in String#toUpperCase().
- *
- * ### Example
- *
- * ```typescript
- * @Model()
- * export class EventModel {
- *   @Uppercase()
- *   field: string;
- * }
- * ```
- *
- * @param {boolean} uppercase
- * @returns {Function}
- * @decorator
- * @mongoose
- * @property
- */
-export function Uppercase(uppercase: boolean = true): PropertyDecorator {
-  return MongooseSchema({uppercase} as any);
-}

package/src/decorators/versionKey.spec.ts

@@ -1,19 +0,0 @@
-import {Store} from "@tsed/core";
-
-import {MONGOOSE_SCHEMA_OPTIONS} from "../constants/constants.js";
-import {Model} from "./model.js";
-import {VersionKey} from "./versionKey.js";
-
-describe("@VersionKey()", () => {
-  it("should set metadata", () => {
-    @Model()
-    class TestVersionKey {
-      @VersionKey()
-      rev: number;
-    }
-
-    expect(Store.from(TestVersionKey).get(MONGOOSE_SCHEMA_OPTIONS)).toEqual({
-      versionKey: "rev"
-    });
-  });
-});

package/src/decorators/versionKey.ts

@@ -1,9 +0,0 @@
-import {Store} from "@tsed/core";
-
-import {MONGOOSE_SCHEMA_OPTIONS} from "../constants/constants.js";
-
-export function VersionKey(): PropertyDecorator {
-  return (target: any, propertyKey: string) => {
-    Store.from(target).merge(MONGOOSE_SCHEMA_OPTIONS, {versionKey: propertyKey});
-  };
-}

package/src/decorators/virtualRef.spec.ts

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

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