@tsed/schema 8.0.1 → 8.0.3

package/src/decorators/collections/maxProperties.ts

@@ -0,0 +1,82 @@
+import {withErrorMsg} from "../../utils/withErrorMsg.js";
+import {JsonEntityFn} from "../common/jsonEntityFn.js";
+
+/**
+ * An object instance is valid against `maxProperties` if its number of properties is less than, or equal to, the value of this keyword.
+ *
+ * ::: warning
+ * The value of this keyword MUST be a non-negative integer.
+ * :::
+ *
+ * ::: warning
+ * This decorator will be removed in v7.
+ * For v6 user, use @@MaxProperties@@ from @tsed/schema instead of @tsed/platform-http.
+ * :::
+ *
+ * ## Example
+ * ### On prop
+ * ```typescript
+ * class Model {
+ *    @MaxProperties(10)
+ *    property: any;
+ * }
+ * ```
+ *
+ * Will produce:
+ *
+ * ```json
+ * {
+ *   "type": "object",
+ *   "properties": {
+ *     "property": {
+ *       "type": "any",
+ *       "maxProperties": 10
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * ### On class
+ *
+ * ```typescript
+ * @MaxProperties(10)
+ * class Model {
+ * }
+ * ```
+ *
+ * Will produce:
+ *
+ * ```json
+ * {
+ *   "type": "object",
+ *   "maxProperties": 10
+ * }
+ * ```
+ *
+ * ### On Parameter
+ *
+ * ```typescript
+ *
+ * class Model {
+ *   method(@Any() @MaxProperties(10) obj: any){}
+ * }
+ * ```
+ *
+ * @param {number} maxProperties The maximum properties allowed on the given object
+ * @decorator
+ * @validation
+ * @swagger
+ * @schema
+ * @input
+ * @collections
+ * @ajv-errors
+ */
+export const MaxProperties = withErrorMsg("maxProperties", (maxProperties: number) => {
+  if (maxProperties < 0) {
+    throw new Error("The value of maxProperties MUST be a non-negative integer.");
+  }
+
+  return JsonEntityFn((store) => {
+    store.isCollection ? store.schema.maxProperties(maxProperties) : store.itemSchema.maxProperties(maxProperties);
+  });
+});

package/src/decorators/collections/minItems.spec.ts

@@ -0,0 +1,40 @@
+import {getJsonSchema} from "../../utils/getJsonSchema.js";
+import {CollectionOf} from "./collectionOf.js";
+import {MinItems} from "./minItems.js";
+
+describe("@MinItems", () => {
+  it("should declare a prop", () => {
+    // WHEN
+    class Model {
+      @CollectionOf(Number)
+      @MinItems(10)
+      num: number[];
+    }
+
+    // THEN
+    expect(getJsonSchema(Model)).toEqual({
+      properties: {
+        num: {
+          items: {
+            type: "number"
+          },
+          minItems: 10,
+          type: "array"
+        }
+      },
+      type: "object"
+    });
+  });
+  it("should throw error", () => {
+    // WHEN
+    let actualError: any;
+    try {
+      MinItems(-1);
+    } catch (er) {
+      actualError = er;
+    }
+
+    // THEN
+    expect(actualError.message).toBe("The value of minItems MUST be a non-negative integer.");
+  });
+});

package/src/decorators/collections/minItems.ts

@@ -0,0 +1,63 @@
+import {withErrorMsg} from "../../utils/withErrorMsg.js";
+import {JsonEntityFn} from "../common/jsonEntityFn.js";
+
+/**
+ * An array instance is valid against `minItems` if its size is greater than, or equal to, the value of this keyword.
+ *
+ * ::: warning
+ * The value `minItems` MUST be a non-negative integer.
+ * :::
+ *
+ * ::: tip
+ * Omitting this keyword has the same behavior as a value of 0.
+ * :::
+ *
+ * ::: warning
+ * For v6 user, use @@MinItems@@ from @tsed/schema instead of @tsed/platform-http.
+ * :::
+ *
+ * ## Example
+ *
+ * ```typescript
+ * class Model {
+ *    @CollectionOf(String)
+ *    @MinItems(10)
+ *    property: string[];
+ * }
+ * ```
+ *
+ * Will produce:
+ *
+ * ```json
+ * {
+ *   "type": "object",
+ *   "properties": {
+ *     "property": {
+ *       "type": "array",
+ *       "minItems": 10,
+ *       "items": {
+ *         "type": "string"
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @param {number} minItems
+ * @decorator
+ * @validation
+ * @swagger
+ * @schema
+ * @input
+ * @collections
+ * @ajv-errors
+ */
+export const MinItems = withErrorMsg("minItems", (minItems: number) => {
+  if (minItems < 0) {
+    throw new Error("The value of minItems MUST be a non-negative integer.");
+  }
+
+  return JsonEntityFn((storedJson) => {
+    storedJson.schema.minItems(minItems);
+  });
+});

package/src/decorators/collections/minProperties.spec.ts

@@ -0,0 +1,109 @@
+import {SpecTypes} from "../../domain/SpecTypes.js";
+import {getJsonSchema} from "../../utils/getJsonSchema.js";
+import {getSpec} from "../../utils/getSpec.js";
+import {In} from "../operations/in.js";
+import {OperationPath} from "../operations/operationPath.js";
+import {MinProperties} from "./minProperties.js";
+
+describe("@MinProperties", () => {
+  it("should declare min value (any)", () => {
+    // WHEN
+    class Model {
+      @MinProperties(10)
+      prop: any;
+    }
+
+    // THEN
+    expect(getJsonSchema(Model)).toEqual({
+      properties: {
+        prop: {
+          minProperties: 10,
+          type: "object"
+        }
+      },
+      type: "object"
+    });
+  });
+  it("should declare min value (Map<any>)", () => {
+    // WHEN
+    class Model {
+      @MinProperties(10)
+      prop: Map<string, any>;
+    }
+
+    // THEN
+    expect(getJsonSchema(Model)).toEqual({
+      properties: {
+        prop: {
+          minProperties: 10,
+          type: "object"
+        }
+      },
+      type: "object"
+    });
+  });
+  it("should declare min value on class", () => {
+    // WHEN
+    @MinProperties(10)
+    class Model {}
+
+    // THEN
+    expect(getJsonSchema(Model)).toEqual({
+      minProperties: 10,
+      type: "object"
+    });
+  });
+  it("should declare min value on param", () => {
+    // WHEN
+    class MyController {
+      @OperationPath("POST", "/")
+      method(@In("body") @MinProperties(10) test: any) {}
+    }
+
+    // THEN
+    expect(getSpec(MyController, {specType: SpecTypes.OPENAPI})).toEqual({
+      paths: {
+        "/": {
+          post: {
+            operationId: "myControllerMethod",
+            parameters: [],
+            requestBody: {
+              content: {
+                "application/json": {
+                  schema: {
+                    minProperties: 10,
+                    type: "object"
+                  }
+                }
+              },
+              required: false
+            },
+            responses: {
+              "200": {
+                description: "Success"
+              }
+            },
+            tags: ["MyController"]
+          }
+        }
+      },
+      tags: [
+        {
+          name: "MyController"
+        }
+      ]
+    });
+  });
+  it("should throw an error when the given parameters is as negative integer", () => {
+    // WHEN
+    let actualError: any;
+    try {
+      MinProperties(-1);
+    } catch (er) {
+      actualError = er;
+    }
+
+    // THEN
+    expect(actualError.message).toBe("The value of minProperties MUST be a non-negative integer.");
+  });
+});

package/src/decorators/collections/minProperties.ts

@@ -0,0 +1,81 @@
+import {withErrorMsg} from "../../utils/withErrorMsg.js";
+import {JsonEntityFn} from "../common/jsonEntityFn.js";
+
+/**
+ * An object instance is valid against `minProperties` if its number of properties is less than, or equal to, the value of this keyword.
+ *
+ * ::: warning
+ * The value of this keyword MUST be a non-negative integer.
+ * :::
+ *
+ * ::: warning
+ * For v6 user, use @@MinProperties@@ from @tsed/schema instead of @tsed/platform-http.
+ * :::
+ *
+ * ## Example
+ * ### On prop
+ * ```typescript
+ * class Model {
+ *    @MinProperties(10)
+ *    property: any;
+ * }
+ * ```
+ *
+ * Will produce:
+ *
+ * ```json
+ * {
+ *   "type": "object",
+ *   "properties": {
+ *     "property": {
+ *       "type": "any",
+ *       "minProperties": 10
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * ### On class
+ *
+ * ```typescript
+ * @MinProperties(10)
+ * class Model {
+ * }
+ * ```
+ *
+ * Will produce:
+ *
+ * ```json
+ * {
+ *   "type": "object",
+ *   "minProperties": 10
+ * }
+ * ```
+ *
+ * ### On Parameter
+ *
+ * ```typescript
+ *
+ * class Model {
+ *   method(@Any() @MinProperties(10) obj: any){}
+ * }
+ * ```
+ *
+ * @param {number} minProperties The minimum properties allowed on the object.
+ * @decorator
+ * @validation
+ * @swagger
+ * @schema
+ * @input
+ * @collections
+ * @ajv-errors
+ */
+export const MinProperties = withErrorMsg("minProperties", (minProperties: number) => {
+  if (minProperties < 0) {
+    throw new Error("The value of minProperties MUST be a non-negative integer.");
+  }
+
+  return JsonEntityFn((store) => {
+    store.isCollection ? store.schema.minProperties(minProperties) : store.itemSchema.minProperties(minProperties);
+  });
+});

package/src/decorators/collections/uniqueItems.spec.ts

@@ -0,0 +1,28 @@
+import {getJsonSchema} from "../../utils/getJsonSchema.js";
+import {CollectionOf} from "./collectionOf.js";
+import {UniqueItems} from "./uniqueItems.js";
+
+describe("@UniqueItems", () => {
+  it("should declare a prop", () => {
+    // WHEN
+    class Model {
+      @CollectionOf(Number)
+      @UniqueItems(true)
+      num: number[];
+    }
+
+    // THEN
+    expect(getJsonSchema(Model)).toEqual({
+      properties: {
+        num: {
+          items: {
+            type: "number"
+          },
+          uniqueItems: true,
+          type: "array"
+        }
+      },
+      type: "object"
+    });
+  });
+});

package/src/decorators/collections/uniqueItems.ts

@@ -0,0 +1,59 @@
+import {JsonEntityStore} from "../../domain/JsonEntityStore.js";
+import {withErrorMsg} from "../../utils/withErrorMsg.js";
+import {JsonEntityFn} from "../common/jsonEntityFn.js";
+
+/**
+ * If this keyword has boolean value false, the instance validates successfully. If it has boolean value true, the instance validates successfully if all of its elements are unique.
+ *
+ * ::: warning
+ * For v6 user, use @@UniqueItems@@ from @tsed/schema instead of @tsed/platform-http.
+ * :::
+ *
+ * ## Example
+ *
+ * ```typescript
+ * class Model {
+ *    @UniqueItems()  // default true
+ *    property: number[];
+ * }
+ * ```
+ *
+ *  * ```typescript
+ * class Model {
+ *    @CollectionOf(String)
+ *    @UniqueItems()
+ *    property: string[];
+ * }
+ * ```
+ *
+ * Will produce:
+ *
+ * ```json
+ * {
+ *   "type": "object",
+ *   "properties": {
+ *     "property": {
+ *       "type": "array",
+ *       "uniqueItems": true,
+ *       "items": {
+ *         "type": "string"
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @param {boolean} uniqueItems
+ * @decorator
+ * @validation
+ * @swagger
+ * @schema
+ * @input
+ * @collections
+ * @ajv-errors
+ */
+export const UniqueItems = withErrorMsg("uniqueItems", (uniqueItems: boolean = true) => {
+  return JsonEntityFn((store: JsonEntityStore) => {
+    store.schema.uniqueItems(uniqueItems);
+  });
+});