@tsed/schema 8.0.1 → 8.0.2

package/src/decorators/common/maximum.spec.ts

@@ -0,0 +1,73 @@
+import "../../index.js";
+
+import {JsonEntityStore} from "../../domain/JsonEntityStore.js";
+import {CollectionOf} from "../collections/collectionOf.js";
+import {Max} from "./maximum.js";
+
+describe("@Maximum", () => {
+  it("should declare maximum value", () => {
+    // WHEN
+    class Model {
+      @Max(0)
+      num: number;
+    }
+
+    // THEN
+    const classSchema = JsonEntityStore.from(Model);
+
+    expect(classSchema.schema.toJSON()).toEqual({
+      properties: {
+        num: {
+          maximum: 0,
+          type: "number"
+        }
+      },
+      type: "object"
+    });
+  });
+
+  it("should declare exclusive maximum value", () => {
+    // WHEN
+    class Model {
+      @Max(0, true)
+      num: number;
+    }
+
+    // THEN
+    const classSchema = JsonEntityStore.from(Model);
+
+    expect(classSchema.schema.toJSON()).toEqual({
+      properties: {
+        num: {
+          exclusiveMaximum: 0,
+          type: "number"
+        }
+      },
+      type: "object"
+    });
+  });
+  it("should declare maximum value (collection)", () => {
+    // WHEN
+    class Model {
+      @Max(0)
+      @CollectionOf(Number)
+      num: number[];
+    }
+
+    // THEN
+    const classSchema = JsonEntityStore.from(Model);
+
+    expect(classSchema.schema.toJSON()).toEqual({
+      properties: {
+        num: {
+          type: "array",
+          items: {
+            maximum: 0,
+            type: "number"
+          }
+        }
+      },
+      type: "object"
+    });
+  });
+});

package/src/decorators/common/maximum.ts

@@ -0,0 +1,146 @@
+import {withErrorMsg} from "../../utils/withErrorMsg.js";
+import {JsonEntityFn} from "./jsonEntityFn.js";
+
+/**
+ * The value of `maximum` MUST be a number, representing an inclusive upper limit for a numeric instance.
+ *
+ * If the instance is a number, then this keyword validates only if the instance is less than or exactly equal to `maximum`.
+ *
+ * ::: warning
+ * For v6 user, use @@Maximum@@ from @tsed/schema instead of @tsed/platform-http.
+ * :::
+ *
+ * ## Example
+ * ### With primitive type
+ *
+ * ```typescript
+ * class Model {
+ *    @Maximum(10)
+ *    property: number;
+ * }
+ * ```
+ *
+ * Will produce:
+ *
+ * ```json
+ * {
+ *   "type": "object",
+ *   "properties": {
+ *     "property": {
+ *       "type": "number",
+ *       "maximum": 10
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * ### With array type
+ *
+ * ```typescript
+ * class Model {
+ *    @Maximum(10)
+ *    @CollectionOf(Number)
+ *    property: number[];
+ * }
+ * ```
+ *
+ * Will produce:
+ *
+ * ```json
+ * {
+ *   "type": "object",
+ *   "properties": {
+ *     "property": {
+ *       "type": "array",
+ *       "items": {
+ *          "type": "number",
+ *          "maximum": 10
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @param {number} maximum The maximum value allowed
+ * @param {boolean} exclusive Same effect as ExclusiveMaximum decorator.
+ * @decorator
+ * @validation
+ * @swagger
+ * @schema
+ * @input
+ * @ajv-errors
+ */
+export const Maximum = withErrorMsg("maximum", (maximum: number, exclusive: boolean = false) => {
+  return JsonEntityFn((store) => {
+    exclusive ? store.itemSchema.exclusiveMaximum(maximum) : store.itemSchema.maximum(maximum);
+  });
+});
+/**
+ * The value of `maximum` MUST be a number, representing an inclusive upper limit for a numeric instance.
+ *
+ * If the instance is a number, then this keyword validates only if the instance is less than or exactly equal to `maximum`.
+ *
+ * ::: warning
+ * For v6 user, use @@Maximum@@ from @tsed/schema instead of @tsed/platform-http.
+ * :::
+ *
+ * ## Example
+ * ### With primitive type
+ *
+ * ```typescript
+ * class Model {
+ *    @Max(10)
+ *    property: number;
+ * }
+ * ```
+ *
+ * Will produce:
+ *
+ * ```json
+ * {
+ *   "type": "object",
+ *   "properties": {
+ *     "property": {
+ *       "type": "number",
+ *       "maximum": 10
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * ### With array type
+ *
+ * ```typescript
+ * class Model {
+ *    @Max(10)
+ *    @CollectionOf(Number)
+ *    property: number[];
+ * }
+ * ```
+ *
+ * Will produce:
+ *
+ * ```json
+ * {
+ *   "type": "object",
+ *   "properties": {
+ *     "property": {
+ *       "type": "array",
+ *       "items": {
+ *          "type": "number",
+ *          "maximum": 10
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @param {number} maximum The maximum value allowed
+ * @param {boolean} exclusive Same effect as ExclusiveMaximum decorator.
+ * @decorator
+ * @validation
+ * @swagger
+ * @schema
+ * @input
+ */
+export const Max = Maximum;

package/src/decorators/common/minLength.spec.ts

@@ -0,0 +1,186 @@
+import "../../index.js";
+
+import {validateModel} from "../../../test/helpers/validateModel.js";
+import {JsonEntityStore} from "../../domain/JsonEntityStore.js";
+import {getJsonSchema} from "../../utils/getJsonSchema.js";
+import {CollectionOf} from "../collections/collectionOf.js";
+import {MinLength} from "./minLength.js";
+
+describe("@MinLength", () => {
+  it("should declare minimum value", () => {
+    // WHEN
+    class Model {
+      @MinLength(0)
+      word: string;
+    }
+
+    // THEN
+    const classSchema = JsonEntityStore.from(Model);
+
+    expect(classSchema.schema.toJSON()).toEqual({
+      properties: {
+        word: {
+          minLength: 0,
+          type: "string"
+        }
+      },
+      type: "object"
+    });
+  });
+  it("should throw error", () => {
+    // WHEN
+    let actualError: any;
+    try {
+      MinLength(-1);
+    } catch (er) {
+      actualError = er;
+    }
+
+    // THEN
+    expect(actualError.message).toBe("The value of minLength MUST be a non-negative integer.");
+  });
+  it("should declare minimum value on type (collection)", () => {
+    // WHEN
+    class Model {
+      @MinLength(0)
+      @CollectionOf(String)
+      words: string[];
+    }
+
+    // THEN
+    const classSchema = JsonEntityStore.from(Model);
+
+    expect(classSchema.schema.toJSON()).toEqual({
+      properties: {
+        words: {
+          type: "array",
+          items: {
+            minLength: 0,
+            type: "string"
+          }
+        }
+      },
+      type: "object"
+    });
+  });
+  it("should declare minimum value on collection (collection)", () => {
+    // WHEN
+    class Model {
+      @MinLength(0)
+      @(CollectionOf(String).MinItems(0).MaxItems(10))
+      words: string[];
+    }
+
+    // THEN
+    const classSchema = JsonEntityStore.from(Model);
+
+    expect(classSchema.schema.toJSON()).toEqual({
+      properties: {
+        words: {
+          type: "array",
+          items: {
+            minLength: 0,
+            type: "string"
+          },
+          maxItems: 10,
+          minItems: 0
+        }
+      },
+      type: "object"
+    });
+  });
+  it("should declare minLength field with custom error message", () => {
+    // WHEN
+    class Model {
+      @(MinLength(2).Error("Require at least 2 characters"))
+      @(CollectionOf(String).MinItems(0).MaxItems(10))
+      words: string[];
+    }
+
+    // THEN
+    const schema = getJsonSchema(Model, {customKeys: true});
+
+    expect(schema).toEqual({
+      properties: {
+        words: {
+          items: {
+            minLength: 2,
+            type: "string",
+            errorMessage: {
+              minLength: "Require at least 2 characters"
+            }
+          },
+          maxItems: 10,
+          minItems: 0,
+          type: "array"
+        }
+      },
+      type: "object"
+    });
+
+    const result = validateModel(
+      {
+        words: ["a"]
+      },
+      Model
+    );
+
+    expect(result).toEqual([
+      {
+        instancePath: "/words/0",
+        keyword: "errorMessage",
+        message: "Require at least 2 characters",
+        params: {
+          errors: [
+            {
+              emUsed: true,
+              instancePath: "/words/0",
+              keyword: "minLength",
+              message: "must NOT have fewer than 2 characters",
+              params: {
+                limit: 2
+              },
+              schemaPath: "#/properties/words/items/minLength"
+            }
+          ]
+        },
+        schemaPath: "#/properties/words/items/errorMessage"
+      }
+    ]);
+  });
+
+  it("should throw error with custom error message", () => {
+    // WHEN
+    class Model {
+      @(MinLength(10).Error("Title must be at least 10 characters long"))
+      word: string;
+    }
+
+    // THEN
+
+    const result = validateModel({word: "test"}, Model);
+
+    expect(result).toEqual([
+      {
+        instancePath: "/word",
+        keyword: "errorMessage",
+        message: "Title must be at least 10 characters long",
+        params: {
+          errors: [
+            {
+              emUsed: true,
+              instancePath: "/word",
+              keyword: "minLength",
+              message: "must NOT have fewer than 10 characters",
+              params: {
+                limit: 10
+              },
+              schemaPath: "#/properties/word/minLength"
+            }
+          ]
+        },
+        schemaPath: "#/properties/word/errorMessage"
+      }
+    ]);
+  });
+});

package/src/decorators/common/minLength.ts

@@ -0,0 +1,89 @@
+import {withErrorMsg} from "../../utils/withErrorMsg.js";
+import {JsonEntityFn} from "./jsonEntityFn.js";
+
+/**
+ *
+ * A string instance is valid against this keyword if its length is greater than, or equal to, the value of this keyword.
+ *
+ * The length of a string instance is defined as the number of its characters as defined by [RFC 7159](http://json-schema.org/latest/json-schema-validation.html#RFC7159).
+ *
+ * ::: warning
+ * The value of minLength MUST be a non-negative integer.
+ * :::
+ *
+ * ::: tip
+ * Omitting this keyword has the same behavior as a value of 0.
+ * :::
+ *
+ * ::: warning
+ * For v6 user, use @@MinLength@@ from @tsed/schema instead of @tsed/platform-http.
+ * :::
+ *
+ * ## Example
+ * ### With primitive type
+ *
+ * ```typescript
+ * class Model {
+ *    @MinLength(10)
+ *    property: number;
+ * }
+ * ```
+ *
+ * Will produce:
+ *
+ * ```json
+ * {
+ *   "type": "object",
+ *   "properties": {
+ *     "property": {
+ *       "type": "string",
+ *       "maxLength": 10
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * ### With array type
+ *
+ * ```typescript
+ * class Model {
+ *    @MinLength(10)
+ *    @CollectionOf(String)
+ *    property: string[];
+ * }
+ * ```
+ *
+ * Will produce:
+ *
+ * ```json
+ * {
+ *   "type": "object",
+ *   "properties": {
+ *     "property": {
+ *       "type": "array",
+ *       "items": {
+ *          "type": "string",
+ *          "minLength": 10
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @param {number} minLength
+ * @decorator
+ * @validation
+ * @swagger
+ * @schema
+ * @input
+ * @ajv-errors
+ */
+export const MinLength = withErrorMsg("minLength", (minLength: number) => {
+  if (minLength < 0) {
+    throw new Error("The value of minLength MUST be a non-negative integer.");
+  }
+
+  return JsonEntityFn((store) => {
+    store.itemSchema.minLength(minLength);
+  });
+});

package/src/decorators/common/minimum.spec.ts

@@ -0,0 +1,74 @@
+import "../../index.js";
+
+import {JsonEntityStore} from "../../domain/JsonEntityStore.js";
+import {CollectionOf} from "../collections/collectionOf.js";
+import {Min} from "./minimum.js";
+
+describe("@Minimum", () => {
+  it("should declare minimum value", () => {
+    // WHEN
+    class Model {
+      @Min(0)
+      num: number;
+    }
+
+    // THEN
+    const classSchema = JsonEntityStore.from(Model);
+
+    expect(classSchema.schema.toJSON()).toEqual({
+      properties: {
+        num: {
+          minimum: 0,
+          type: "number"
+        }
+      },
+      type: "object"
+    });
+  });
+
+  it("should declare exclusive minimum value", () => {
+    // WHEN
+    class Model {
+      @Min(0, true)
+      num: number;
+    }
+
+    // THEN
+    const classSchema = JsonEntityStore.from(Model);
+
+    expect(classSchema.schema.toJSON()).toEqual({
+      properties: {
+        num: {
+          exclusiveMinimum: 0,
+          type: "number"
+        }
+      },
+      type: "object"
+    });
+  });
+
+  it("should declare minimum value (collection)", () => {
+    // WHEN
+    class Model {
+      @Min(0)
+      @CollectionOf(Number)
+      num: number[];
+    }
+
+    // THEN
+    const classSchema = JsonEntityStore.from(Model);
+
+    expect(classSchema.schema.toJSON()).toEqual({
+      properties: {
+        num: {
+          type: "array",
+          items: {
+            minimum: 0,
+            type: "number"
+          }
+        }
+      },
+      type: "object"
+    });
+  });
+});

package/src/decorators/common/minimum.ts

@@ -0,0 +1,145 @@
+import {withErrorMsg} from "../../utils/withErrorMsg.js";
+import {JsonEntityFn} from "./jsonEntityFn.js";
+
+/**
+ * The value of `minimum` MUST be a number, representing an inclusive upper limit for a numeric instance.
+ *
+ * If the instance is a number, then this keyword validates only if the instance is greater than or exactly equal to `minimum`.
+ *
+ * ::: warning
+ * This decorator will be removed in v7.
+ * For v6 user, use @@Minimum@@ from @tsed/schema instead of @tsed/platform-http.
+ * :::
+ *
+ * ## Example
+ * ### With primitive type
+ *
+ * ```typescript
+ * class Model {
+ *    @Minimum(10)
+ *    property: number;
+ * }
+ * ```
+ *
+ * Will produce:
+ *
+ * ```json
+ * {
+ *   "type": "object",
+ *   "properties": {
+ *     "property": {
+ *       "type": "number",
+ *       "minimum": 10
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * ### With array type
+ *
+ * ```typescript
+ * class Model {
+ *    @Minimum(10)
+ *    @CollectionOf(Number)
+ *    property: number[];
+ * }
+ * ```
+ *
+ * Will produce:
+ *
+ * ```json
+ * {
+ *   "type": "object",
+ *   "properties": {
+ *     "property": {
+ *       "type": "array",
+ *       "items": {
+ *          "type": "number",
+ *          "minimum": 10
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @param {number} minimum The minimum value allowed
+ * @param {boolean} exclusive
+ * @decorator
+ * @validation
+ * @swagger
+ * @schema
+ * @input
+ * @ajv-errors
+ */
+export const Minimum = withErrorMsg("minimum", (minimum: number, exclusive: boolean = false) => {
+  return JsonEntityFn((store) => {
+    exclusive ? store.itemSchema.exclusiveMinimum(minimum) : store.itemSchema.minimum(minimum);
+  });
+});
+
+/**
+ * The value of `minimum` MUST be a number, representing an inclusive upper limit for a numeric instance.
+ *
+ * If the instance is a number, then this keyword validates only if the instance is greater than or exactly equal to `minimum`.
+ *
+ * ## Example
+ * ### With primitive type
+ *
+ * ```typescript
+ * class Model {
+ *    @Min(10)
+ *    property: number;
+ * }
+ * ```
+ *
+ * Will produce:
+ *
+ * ```json
+ * {
+ *   "type": "object",
+ *   "properties": {
+ *     "property": {
+ *       "type": "number",
+ *       "minimum": 10
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * ### With array type
+ *
+ * ```typescript
+ * class Model {
+ *    @Min(10)
+ *    @CollectionOf(Number)
+ *    property: number[];
+ * }
+ * ```
+ *
+ * Will produce:
+ *
+ * ```json
+ * {
+ *   "type": "object",
+ *   "properties": {
+ *     "property": {
+ *       "type": "array",
+ *       "items": {
+ *          "type": "number",
+ *          "minimum": 10
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @alias Minimum
+ * @param minimum The minimum value allowed
+ * @param exclusive
+ * @decorator
+ * @validation
+ * @swagger
+ * @schema
+ * @input
+ */
+export const Min = Minimum;