@tsed/mongoose 8.11.1 → 8.11.2-rc.1

package/src/decorators/ref.spec.ts

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

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

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

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

package/src/decorators/schemaIgnore.ts

@@ -1,24 +0,0 @@
-import {MongooseSchema} from "./schema.js";
-
-/**
- * Do not apply this property to schema (create virtual property)
- *
- * ### Example
- *
- * ```typescript
- * @Model()
- * @SchemaIgnore()
- * @Property()
- * kind: string;
- *
- * ```
- *
- * @returns {Function}
- * @decorator
- * @mongoose
- * @class
- */
-
-export function SchemaIgnore(): Function {
-  return MongooseSchema({schemaIgnore: true} as any);
-}

package/src/decorators/select.spec.ts

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

package/src/decorators/select.ts

@@ -1,24 +0,0 @@
-import {MongooseSchema} from "./schema.js";
-
-/**
- * Tell Mongoose to set default select() behavior for this path.
- *
- * ### Example
- *
- * ```typescript
- * @Model()
- * export class EventModel {
- *   @Select()
- *   field: string;
- * }
- * ```
- *
- * @param {boolean | any} select
- * @returns {Function}
- * @decorator
- * @mongoose
- * @property
- */
-export function Select(select: boolean | any = true) {
-  return MongooseSchema({select});
-}

package/src/decorators/sparse.spec.ts

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

package/src/decorators/sparse.ts

@@ -1,26 +0,0 @@
-import {MongooseSchema} from "./schema.js";
-
-/**
- * If [truthy](https://masteringjs.io/tutorials/fundamentals/truthy), Mongoose will
- * disallow changes to this path once the document is saved to the database for the first time. Read more
- * about [immutability in Mongoose here](http://thecodebarbarian.com/whats-new-in-mongoose-5-6-immutable-properties.html).
- *
- * ### Example
- *
- * ```typescript
- * @Model()
- * export class EventModel {
- *   @Sparse()
- *   field: string;
- * }
- * ```
- *
- * @param {boolean | number} sparse
- * @returns {Function}
- * @decorator
- * @mongoose
- * @property
- */
-export function Sparse(sparse: boolean | number = true): PropertyDecorator {
-  return MongooseSchema({sparse} as any);
-}