@tsed/mongoose 8.11.1 → 8.11.2-rc.1

package/src/decorators/auto.spec.ts

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

package/src/decorators/auto.ts

@@ -1,24 +0,0 @@
-import {MongooseSchema} from "./schema.js";
-
-/**
- * If true, uses Mongoose's default _id settings. Only allowed for ObjectIds
- *
- * ### Example
- *
- * ```typescript
- * @Model()
- * export class EventModel {
- *   @ExcludeIndexes()
- *   field: string;
- * }
- * ```
- *
- * @param {boolean} auto
- * @returns {Function}
- * @decorator
- * @mongoose
- * @property
- */
-export function Auto(auto: boolean = true): PropertyDecorator {
-  return MongooseSchema({auto} as any);
-}

package/src/decorators/discriminatorKey.ts

@@ -1 +0,0 @@
-export {DiscriminatorKey} from "@tsed/schema";

package/src/decorators/dynamicRef.spec.ts

@@ -1,46 +0,0 @@
-import {descriptorOf, Store} from "@tsed/core";
-import {getJsonSchema} from "@tsed/schema";
-import {Schema} from "mongoose";
-
-import {DynamicRef} from "../../src/index.js";
-import {MONGOOSE_MODEL_NAME, MONGOOSE_SCHEMA} from "../constants/constants.js";
-
-describe("@DynamicRef()", () => {
-  it("should set metadata", () => {
-    // GIVEN
-    class RefTest {}
-
-    Store.from(RefTest).set(MONGOOSE_MODEL_NAME, "RefTest");
-
-    // WHEN
-    class Test {
-      @DynamicRef("RefTest")
-      test: DynamicRef<RefTest>;
-    }
-
-    // THEN
-    expect(getJsonSchema(Test)).toEqual({
-      properties: {
-        test: {
-          description: "A reference ObjectID",
-          examples: ["5ce7ad3028890bd71749d477"],
-          oneOf: [
-            {
-              description: "A reference ObjectID",
-              examples: ["5ce7ad3028890bd71749d477"],
-              type: "string"
-            }
-          ]
-        }
-      },
-      type: "object"
-    });
-
-    const store = Store.from(Test, "test", descriptorOf(Test, "test"));
-
-    expect(store.get(MONGOOSE_SCHEMA)).toEqual({
-      type: Schema.Types.ObjectId,
-      refPath: "RefTest"
-    });
-  });
-});

package/src/decorators/dynamicRef.ts

@@ -1,76 +0,0 @@
-import {classOf, isArrowFn, isString, StoreMerge, Type, useDecorators} from "@tsed/core";
-import {deserialize, OnDeserialize, OnSerialize, serialize} from "@tsed/json-mapper";
-import {Description, Example, JsonHookContext, OneOf, Property, string} from "@tsed/schema";
-import {Schema as MongooseSchema} from "mongoose";
-
-import {MONGOOSE_SCHEMA} from "../constants/constants.js";
-import {MongooseModels} from "../registries/MongooseModels.js";
-
-function isRef(value: undefined | string | any) {
-  return (value && value._bsontype) || isString(value);
-}
-
-function getType(refPath: string, ctx: JsonHookContext) {
-  return (ctx?.self[refPath] && MongooseModels.get(ctx.self[refPath] as string)) || Object;
-}
-
-/**
- * Define a property as mongoose reference to other Model (decorated with @Model).
- *
- * ### Example
- *
- * ```typescript
- * @Model()
- * class FooModel {
- *
- *    @DynamicRef('type')
- *    field: DynamicRef<OtherFooModel | OtherModel>
- *
- *    @Enum(['OtherFooModel', 'OtherModel'])
- *    type: string
- * }
- *
- * @Model()
- * class OtherFooModel {
- * }
- *
- * @Model()
- * class OtherModel {
- * }
- * ```
- *
- * @param refPath {String} the path to apply the correct model
- * @param types {Type} the classes to generate the correct json schema
- * @returns {Function}
- * @decorator
- * @mongoose
- * @property
- */
-export function DynamicRef(refPath: string, ...types: Type<any>[]): PropertyDecorator {
-  return useDecorators(
-    Property(Object),
-    Example("5ce7ad3028890bd71749d477"),
-    Description("A reference ObjectID"),
-    StoreMerge(MONGOOSE_SCHEMA, {
-      type: MongooseSchema.Types.ObjectId,
-      refPath
-    }),
-    OnDeserialize((value, ctx) => {
-      if (isRef(value)) {
-        return value.toString();
-      }
-
-      return deserialize(value, {...ctx, type: getType(refPath, ctx)});
-    }),
-    OnSerialize((value: any, ctx) => {
-      if (isRef(value)) {
-        return value.toString();
-      }
-
-      return serialize(value, {...ctx, type: getType(refPath, ctx)});
-    }),
-    OneOf(string().example("5ce7ad3028890bd71749d477").description("A reference ObjectID"), ...types)
-  ) as PropertyDecorator;
-}
-
-export type DynamicRef<T> = T | string;

package/src/decorators/excludeIndexes.spec.ts

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

package/src/decorators/excludeIndexes.ts

@@ -1,24 +0,0 @@
-import {MongooseSchema} from "./schema.js";
-
-/**
- * If true, Mongoose will skip gathering indexes on subpaths. Only allowed for subdocuments and subdocument arrays.
- *
- * ### Example
- *
- * ```typescript
- * @Model()
- * export class EventModel {
- *   @ExcludeIndexes()
- *   field: string;
- * }
- * ```
- *
- * @param {boolean} excludeIndexes
- * @returns {Function}
- * @decorator
- * @mongoose
- * @property
- */
-export function ExcludeIndexes(excludeIndexes: boolean = true): PropertyDecorator {
-  return MongooseSchema({excludeIndexes} as any);
-}

package/src/decorators/expires.spec.ts

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

package/src/decorators/expires.ts

@@ -1,24 +0,0 @@
-import {MongooseSchema} from "./schema.js";
-
-/**
- * Defines a TTL index on this path. Only allowed for dates.
- *
- * ### Example
- *
- * ```typescript
- * @Model()
- * export class EventModel {
- *   @Expires('5d')
- *   field: string;
- * }
- * ```
- *
- * @param {boolean | any} expires
- * @returns {Function}
- * @decorator
- * @mongoose
- * @property
- */
-export function Expires(expires: number | string | Date): PropertyDecorator {
-  return MongooseSchema({expires} as any);
-}

package/src/decorators/immutable.spec.ts

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

package/src/decorators/immutable.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 {
- *   @Immutable()
- *   field: string;
- * }
- * ```
- *
- * @param {boolean | any} immutable
- * @returns {Function}
- * @decorator
- * @mongoose
- * @property
- */
-export function Immutable(immutable: boolean | ((this: any, doc: any) => boolean) = true): PropertyDecorator {
-  return MongooseSchema({immutable} as any);
-}

package/src/decorators/indexed.spec.ts

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

package/src/decorators/indexed.ts

@@ -1,24 +0,0 @@
-import {IndexOptions} from "mongoose";
-
-import {MongooseSchema} from "./schema.js";
-
-/**
- * Tell Mongoose whether to define an index for the property.
- * ### Example
- *
- * ```typescript
- * @Model()
- * export class EventModel {
- *   @Indexed()
- *   field: string;
- * }
- * ```
- *
- * @returns {Function}
- * @decorator
- * @mongoose
- * @property
- */
-export function Indexed(index: IndexOptions | boolean | string = true): PropertyDecorator {
-  return MongooseSchema({index} as any);
-}

package/src/decorators/lowercase.spec.ts

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

package/src/decorators/lowercase.ts

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

package/src/decorators/model.ts

@@ -1,69 +0,0 @@
-import {useDecorators} from "@tsed/core";
-import {injectable} from "@tsed/di";
-import {Schema} from "mongoose";
-
-import {MongooseModelOptions} from "../interfaces/MongooseModelOptions.js";
-import {MONGOOSE_CONNECTIONS} from "../services/MongooseConnections.js";
-import {createModel, getModelToken} from "../utils/createModel.js";
-import {getSchema} from "../utils/createSchema.js";
-import {applySchemaOptions, schemaOptions} from "../utils/schemaOptions.js";
-
-/**
- * Define a class as a Mongoose Model. The model can be injected to the Service, Controller, Middleware, Converters or Filter with
- * `@Inject` annotation.
- *
- * ### Example
- *
- * ```typescript
- * @Model()
- * export class EventModel {
- *   @Property()
- *   field: string;
- * }
- * ```
- *
- * Then inject the model into a service:
- *
- * ```typescript
- * class MyService {
- *    constructor(@Inject(EventModel) eventModel: MongooseModel<EventModel>) {
- *        eventModel.findById().exec();
- *    }
- * }
- * ```
- *
- * ### Options
- *
- * - `schemaOptions` (mongoose.SchemaOptions): Option to configure the schema behavior.
- * - `name` (String): model name.
- * - `collection` (String): collection (optional, induced from model name).
- * - `skipInit` (Boolean): skipInit whether to skip initialization (defaults to false).
- *
- * @param {MongooseModelOptions} options
- * @returns {(target: any) => void}
- * @decorator
- * @mongoose
- * @class
- */
-export function Model(options: MongooseModelOptions = {}) {
-  return useDecorators((target: any) => {
-    const {token, collectionName} = getModelToken(target, options);
-
-    injectable(token).factory(() => getSchema(target, options as any));
-
-    injectable(target)
-      .type("mongoose:model")
-      .deps([MONGOOSE_CONNECTIONS, token])
-      .factory((connections: MONGOOSE_CONNECTIONS, schema: Schema) => {
-        applySchemaOptions(schema, schemaOptions(target));
-        return createModel(
-          target,
-          schema,
-          collectionName,
-          options.collection,
-          options.overwriteModels,
-          connections.get(options.connection)
-        );
-      });
-  });
-}

package/src/decorators/mongooseIndex.spec.ts

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

package/src/decorators/mongooseIndex.ts

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

package/src/decorators/mongooseIndexes.spec.ts

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

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

@@ -1,25 +0,0 @@
-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: {}
-        }
-      ]
-    });
-  });
-});