@tsed/mongoose 8.0.1 → 8.0.2

package/src/decorators/schemaIgnore.ts

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

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

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

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

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

package/src/decorators/text.spec.ts

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

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

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

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

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

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

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

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

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

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