@tsed/schema 6.88.0 → 6.91.0

package/lib/cjs/decorators/common/hidden.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Hidden = void 0;
+const core_1 = require("@tsed/core");
+/**
+ * Disable documentation for the class and his endpoint.
+ *
+ * ````typescript
+ * @Controller('/')
+ * export class Ctrl {
+ *
+ *   @Get('/')
+ *   @Hidden()
+ *   hiddenRoute(){
+ *
+ *   }
+ * }
+ *
+ * @Controller('/')
+ * @Hidden()
+ * export class Ctrl {
+ *   @Get('/')
+ *   hiddenRoute() {
+ *
+ *   }
+ *   @Get('/2')
+ *   hiddenRoute2() {
+ *
+ *   }
+ * }
+ * ```
+ *
+ * @decorator
+ * @ignore
+ */
+function Hidden() {
+    return (0, core_1.StoreSet)("hidden", true);
+}
+exports.Hidden = Hidden;
+//# sourceMappingURL=hidden.js.map

package/lib/cjs/decorators/common/hidden.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hidden.js","sourceRoot":"","sources":["../../../../src/decorators/common/hidden.ts"],"names":[],"mappings":";;;AAAA,qCAAoC;AAEpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,SAAgB,MAAM;IACpB,OAAO,IAAA,eAAQ,EAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;AAClC,CAAC;AAFD,wBAEC","sourcesContent":["import {StoreSet} from \"@tsed/core\";\n\n/**\n * Disable documentation for the class and his endpoint.\n *\n * ````typescript\n * @Controller('/')\n * export class Ctrl {\n *\n *   @Get('/')\n *   @Hidden()\n *   hiddenRoute(){\n *\n *   }\n * }\n *\n * @Controller('/')\n * @Hidden()\n * export class Ctrl {\n *   @Get('/')\n *   hiddenRoute() {\n *\n *   }\n *   @Get('/2')\n *   hiddenRoute2() {\n *\n *   }\n * }\n * ```\n *\n * @decorator\n * @ignore\n */\nexport function Hidden() {\n  return StoreSet(\"hidden\", true);\n}\n"]}

package/lib/cjs/decorators/common/ignore.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ignore = void 0;
+const jsonEntityFn_1 = require("./jsonEntityFn");
+/**
+ * @ignore
+ */
+const defaultCB = (value, ctx) => ctx.mongoose !== true;
+/**
+ * Ignore the property when JsonMapper serialize the class to a Plain Object JavaScript.
+ *
+ * ::: warning
+ * Swagger will not generate documentation for the ignored property.
+ * :::
+ *
+ * ```typescript
+ * class User {
+ *   @Ignore()
+ *   _id: string;
+ *
+ *   @Property()
+ *   firstName: string;
+ *
+ *   @Property()
+ *   lastName: string;
+ *
+ *   @Ignore((value, ctx) => !ctx.mongoose) // don't ignore prop only if mongoose
+ *   password: string;
+ * }
+ * ```
+ *
+ * The controller:
+ * ```typescript
+ * import {Post, Controller, BodyParams} from "@tsed/common";
+ * import {Person} from "../models/Person";
+ *
+ * @Controller("/")
+ * export class UsersCtrl {
+ *   @Get("/")
+ *   get(): User {
+ *     const user = new User();
+ *     user._id = "12345";
+ *     user.firstName = "John";
+ *     user.lastName = "Doe";
+ *     user.password = "secretpassword";
+ *     return
+ *   }
+ * }
+ * ```
+ *
+ * The expected json object:
+ *
+ * ```json
+ * {
+ *  "firstName": "John",
+ *  "lastName": "Doe"
+ * }
+ * ```
+ * @param cb Callback to know if the property must be ignored
+ * @decorator
+ * @validation
+ * @swagger
+ * @schema
+ */
+function Ignore(cb = defaultCB) {
+    return (0, jsonEntityFn_1.JsonEntityFn)((store) => {
+        store.schema.ignore(cb);
+    });
+}
+exports.Ignore = Ignore;
+//# sourceMappingURL=ignore.js.map

package/lib/cjs/decorators/common/ignore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ignore.js","sourceRoot":"","sources":["../../../../src/decorators/common/ignore.ts"],"names":[],"mappings":";;;AACA,iDAA4C;AAE5C;;GAEG;AACH,MAAM,SAAS,GAAG,CAAC,KAAU,EAAE,GAAQ,EAAE,EAAE,CAAC,GAAG,CAAC,QAAQ,KAAK,IAAI,CAAC;AAElE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,SAAgB,MAAM,CAAC,KAA+B,SAAS;IAC7D,OAAO,IAAA,2BAAY,EAAC,CAAC,KAAK,EAAE,EAAE;QAC5B,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;IAC1B,CAAC,CAAC,CAAC;AACL,CAAC;AAJD,wBAIC","sourcesContent":["import {IgnoreCallback} from \"../../interfaces\";\nimport {JsonEntityFn} from \"./jsonEntityFn\";\n\n/**\n * @ignore\n */\nconst defaultCB = (value: any, ctx: any) => ctx.mongoose !== true;\n\n/**\n * Ignore the property when JsonMapper serialize the class to a Plain Object JavaScript.\n *\n * ::: warning\n * Swagger will not generate documentation for the ignored property.\n * :::\n *\n * ```typescript\n * class User {\n *   @Ignore()\n *   _id: string;\n *\n *   @Property()\n *   firstName: string;\n *\n *   @Property()\n *   lastName: string;\n *\n *   @Ignore((value, ctx) => !ctx.mongoose) // don't ignore prop only if mongoose\n *   password: string;\n * }\n * ```\n *\n * The controller:\n * ```typescript\n * import {Post, Controller, BodyParams} from \"@tsed/common\";\n * import {Person} from \"../models/Person\";\n *\n * @Controller(\"/\")\n * export class UsersCtrl {\n *   @Get(\"/\")\n *   get(): User {\n *     const user = new User();\n *     user._id = \"12345\";\n *     user.firstName = \"John\";\n *     user.lastName = \"Doe\";\n *     user.password = \"secretpassword\";\n *     return\n *   }\n * }\n * ```\n *\n * The expected json object:\n *\n * ```json\n * {\n *  \"firstName\": \"John\",\n *  \"lastName\": \"Doe\"\n * }\n * ```\n * @param cb Callback to know if the property must be ignored\n * @decorator\n * @validation\n * @swagger\n * @schema\n */\nexport function Ignore(cb: boolean | IgnoreCallback = defaultCB) {\n  return JsonEntityFn((store) => {\n    store.schema.ignore(cb);\n  });\n}\n"]}

package/lib/cjs/decorators/common/integer.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Integer = void 0;
+const jsonEntityFn_1 = require("./jsonEntityFn");
+/**
+ * Set integer type.
+ *
+ * ::: warning
+ * For v6 user, use @@Integer@@ from @tsed/schema instead of @@Integer@@ from @tsed/common.
+ * :::
+ *
+ * ## Example
+ *
+ * ```typescript
+ * class Model {
+ *    @Integer()
+ *    property: number;
+ * }
+ * ```
+ *
+ * Will produce:
+ *
+ * ```json
+ * {
+ *   "type": "object",
+ *   "properties": {
+ *     "property": {
+ *       "type": "integer"
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * ### With array of multiple types
+ *
+ * ```typescript
+ * class Model {
+ *    @Integer()
+ *    property: number[];
+ * }
+ * ```
+ *
+ * Will produce:
+ *
+ * ```json
+ * {
+ *   "type": "object",
+ *   "properties": {
+ *     "property": {
+ *       "type": "array",
+ *       "items": {
+ *          "type": "integer"
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @decorator
+ * @validation
+ * @swagger
+ * @schema
+ * @input
+ */
+function Integer() {
+    return (0, jsonEntityFn_1.JsonEntityFn)((store) => {
+        store.itemSchema.type("integer");
+    });
+}
+exports.Integer = Integer;
+//# sourceMappingURL=integer.js.map

package/lib/cjs/decorators/common/integer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"integer.js","sourceRoot":"","sources":["../../../../src/decorators/common/integer.ts"],"names":[],"mappings":";;;AAAA,iDAA4C;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,SAAgB,OAAO;IACrB,OAAO,IAAA,2BAAY,EAAC,CAAC,KAAK,EAAE,EAAE;QAC5B,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IACnC,CAAC,CAAC,CAAC;AACL,CAAC;AAJD,0BAIC","sourcesContent":["import {JsonEntityFn} from \"./jsonEntityFn\";\n\n/**\n * Set integer type.\n *\n * ::: warning\n * For v6 user, use @@Integer@@ from @tsed/schema instead of @@Integer@@ from @tsed/common.\n * :::\n *\n * ## Example\n *\n * ```typescript\n * class Model {\n *    @Integer()\n *    property: number;\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"properties\": {\n *     \"property\": {\n *       \"type\": \"integer\"\n *     }\n *   }\n * }\n * ```\n *\n * ### With array of multiple types\n *\n * ```typescript\n * class Model {\n *    @Integer()\n *    property: number[];\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"properties\": {\n *     \"property\": {\n *       \"type\": \"array\",\n *       \"items\": {\n *          \"type\": \"integer\"\n *       }\n *     }\n *   }\n * }\n * ```\n *\n * @decorator\n * @validation\n * @swagger\n * @schema\n * @input\n */\nexport function Integer() {\n  return JsonEntityFn((store) => {\n    store.itemSchema.type(\"integer\");\n  });\n}\n"]}

package/lib/cjs/decorators/common/jsonEntityFn.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonEntityFn = void 0;
+const getJsonEntityStore_1 = require("../../utils/getJsonEntityStore");
+/**
+ * Decorator util to compose another decorator. See @@Description@@ decorator implementation for more details.
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * export function Description(description: any) {
+ *   return JsonEntityFn((entity: JsonEntityStore, args: DecoratorParameters) => {
+ *       entity.itemSchema.description(description)
+ *   });
+ * }
+ * ```
+ *
+ * @param fn
+ * @decorator
+ * @utils
+ * @model
+ */
+function JsonEntityFn(fn) {
+    return (...parameters) => {
+        const result = fn((0, getJsonEntityStore_1.getJsonEntityStore)(...parameters), parameters);
+        if (typeof result === "function") {
+            result(...parameters);
+        }
+    };
+}
+exports.JsonEntityFn = JsonEntityFn;
+//# sourceMappingURL=jsonEntityFn.js.map

package/lib/cjs/decorators/common/jsonEntityFn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonEntityFn.js","sourceRoot":"","sources":["../../../../src/decorators/common/jsonEntityFn.ts"],"names":[],"mappings":";;;AAEA,uEAAkE;AAElE;;;;;;;;;;;;;;;;;GAiBG;AACH,SAAgB,YAAY,CAC1B,EAAuD;IAEvD,OAAO,CAAC,GAAG,UAA+B,EAAE,EAAE;QAC5C,MAAM,MAAM,GAAQ,EAAE,CAAC,IAAA,uCAAkB,EAAI,GAAG,UAAU,CAAM,EAAE,UAAU,CAAC,CAAC;QAC9E,IAAI,OAAO,MAAM,KAAK,UAAU,EAAE;YAChC,MAAM,CAAC,GAAG,UAAU,CAAC,CAAC;SACvB;IACH,CAAC,CAAC;AACJ,CAAC;AATD,oCASC","sourcesContent":["import {DecoratorParameters} from \"@tsed/core\";\nimport type {JsonEntityStore} from \"../../domain\";\nimport {getJsonEntityStore} from \"../../utils/getJsonEntityStore\";\n\n/**\n * Decorator util to compose another decorator. See @@Description@@ decorator implementation for more details.\n *\n * ## Usage\n *\n * ```typescript\n * export function Description(description: any) {\n *   return JsonEntityFn((entity: JsonEntityStore, args: DecoratorParameters) => {\n *       entity.itemSchema.description(description)\n *   });\n * }\n * ```\n *\n * @param fn\n * @decorator\n * @utils\n * @model\n */\nexport function JsonEntityFn<T extends JsonEntityStore = JsonEntityStore>(\n  fn: (entity: T, parameters: DecoratorParameters) => any\n): (...args: any[]) => any {\n  return (...parameters: DecoratorParameters) => {\n    const result: any = fn(getJsonEntityStore<T>(...parameters) as T, parameters);\n    if (typeof result === \"function\") {\n      result(...parameters);\n    }\n  };\n}\n"]}

package/lib/cjs/decorators/common/maxLength.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MaxLength = void 0;
+const jsonEntityFn_1 = require("./jsonEntityFn");
+/**
+ * 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 maxLength MUST be a non-negative integer.
+ * :::
+ *
+ * ::: tip
+ * Omitting this keyword has the same behavior as a value of 0.
+ * :::
+ *
+ * ::: warning
+ * For v6 user, use @@MaxLength@@ from @tsed/schema instead of @tsed/common.
+ * :::
+ *
+ * ## Example
+ * ### With primitive type
+ *
+ * ```typescript
+ * class Model {
+ *    @MaxLength(10)
+ *    property: number;
+ * }
+ * ```
+ *
+ * Will produce:
+ *
+ * ```json
+ * {
+ *   "type": "object",
+ *   "properties": {
+ *     "property": {
+ *       "type": "string",
+ *       "maxLength": 10
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * ### With array type
+ *
+ * ```typescript
+ * class Model {
+ *    @MaxLength(10)
+ *    @CollectionOf(String)
+ *    property: string[];
+ * }
+ * ```
+ *
+ * Will produce:
+ *
+ * ```json
+ * {
+ *   "type": "object",
+ *   "properties": {
+ *     "property": {
+ *       "type": "array",
+ *       "items": {
+ *          "type": "string",
+ *          "maxLength": 10
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @param {number} maxLength The maximum length allowed
+ * @decorator
+ * @validation
+ * @swagger
+ * @schema
+ * @input
+ */
+function MaxLength(maxLength) {
+    if (maxLength < 0) {
+        throw new Error("The value of maxLength MUST be a non-negative integer.");
+    }
+    return (0, jsonEntityFn_1.JsonEntityFn)((store) => {
+        store.itemSchema.maxLength(maxLength);
+    });
+}
+exports.MaxLength = MaxLength;
+//# sourceMappingURL=maxLength.js.map

package/lib/cjs/decorators/common/maxLength.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"maxLength.js","sourceRoot":"","sources":["../../../../src/decorators/common/maxLength.ts"],"names":[],"mappings":";;;AAAA,iDAA4C;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0EG;AACH,SAAgB,SAAS,CAAC,SAAiB;IACzC,IAAI,SAAS,GAAG,CAAC,EAAE;QACjB,MAAM,IAAI,KAAK,CAAC,wDAAwD,CAAC,CAAC;KAC3E;IAED,OAAO,IAAA,2BAAY,EAAC,CAAC,KAAK,EAAE,EAAE;QAC5B,KAAK,CAAC,UAAU,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;IACxC,CAAC,CAAC,CAAC;AACL,CAAC;AARD,8BAQC","sourcesContent":["import {JsonEntityFn} from \"./jsonEntityFn\";\n\n/**\n * A string instance is valid against this keyword if its length is greater than, or equal to, the value of this keyword.\n *\n * 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).\n *\n * ::: warning\n * The value of maxLength MUST be a non-negative integer.\n * :::\n *\n * ::: tip\n * Omitting this keyword has the same behavior as a value of 0.\n * :::\n *\n * ::: warning\n * For v6 user, use @@MaxLength@@ from @tsed/schema instead of @tsed/common.\n * :::\n *\n * ## Example\n * ### With primitive type\n *\n * ```typescript\n * class Model {\n *    @MaxLength(10)\n *    property: number;\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"properties\": {\n *     \"property\": {\n *       \"type\": \"string\",\n *       \"maxLength\": 10\n *     }\n *   }\n * }\n * ```\n *\n * ### With array type\n *\n * ```typescript\n * class Model {\n *    @MaxLength(10)\n *    @CollectionOf(String)\n *    property: string[];\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"properties\": {\n *     \"property\": {\n *       \"type\": \"array\",\n *       \"items\": {\n *          \"type\": \"string\",\n *          \"maxLength\": 10\n *       }\n *     }\n *   }\n * }\n * ```\n *\n * @param {number} maxLength The maximum length allowed\n * @decorator\n * @validation\n * @swagger\n * @schema\n * @input\n */\nexport function MaxLength(maxLength: number) {\n  if (maxLength < 0) {\n    throw new Error(\"The value of maxLength MUST be a non-negative integer.\");\n  }\n\n  return JsonEntityFn((store) => {\n    store.itemSchema.maxLength(maxLength);\n  });\n}\n"]}

package/lib/cjs/decorators/common/maximum.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Max = exports.Maximum = void 0;
+const jsonEntityFn_1 = require("./jsonEntityFn");
+/**
+ * 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/common.
+ * :::
+ *
+ * ## 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
+ */
+function Maximum(maximum, exclusive = false) {
+    return (0, jsonEntityFn_1.JsonEntityFn)((store) => {
+        exclusive ? store.itemSchema.exclusiveMaximum(maximum) : store.itemSchema.maximum(maximum);
+    });
+}
+exports.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/common.
+ * :::
+ *
+ * ## 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
+ */
+function Max(maximum, exclusive = false) {
+    return Maximum(maximum, exclusive);
+}
+exports.Max = Max;
+//# sourceMappingURL=maximum.js.map

package/lib/cjs/decorators/common/maximum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"maximum.js","sourceRoot":"","sources":["../../../../src/decorators/common/maximum.ts"],"names":[],"mappings":";;;AAAA,iDAA4C;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AACH,SAAgB,OAAO,CAAC,OAAe,EAAE,YAAqB,KAAK;IACjE,OAAO,IAAA,2BAAY,EAAC,CAAC,KAAK,EAAE,EAAE;QAC5B,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IAC7F,CAAC,CAAC,CAAC;AACL,CAAC;AAJD,0BAIC;AACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AACH,SAAgB,GAAG,CAAC,OAAe,EAAE,YAAqB,KAAK;IAC7D,OAAO,OAAO,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;AACrC,CAAC;AAFD,kBAEC","sourcesContent":["import {JsonEntityFn} from \"./jsonEntityFn\";\n\n/**\n * The value of `maximum` MUST be a number, representing an inclusive upper limit for a numeric instance.\n *\n * If the instance is a number, then this keyword validates only if the instance is less than or exactly equal to `maximum`.\n *\n * ::: warning\n * For v6 user, use @@Maximum@@ from @tsed/schema instead of @tsed/common.\n * :::\n *\n * ## Example\n * ### With primitive type\n *\n * ```typescript\n * class Model {\n *    @Maximum(10)\n *    property: number;\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"properties\": {\n *     \"property\": {\n *       \"type\": \"number\",\n *       \"maximum\": 10\n *     }\n *   }\n * }\n * ```\n *\n * ### With array type\n *\n * ```typescript\n * class Model {\n *    @Maximum(10)\n *    @CollectionOf(Number)\n *    property: number[];\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"properties\": {\n *     \"property\": {\n *       \"type\": \"array\",\n *       \"items\": {\n *          \"type\": \"number\",\n *          \"maximum\": 10\n *       }\n *     }\n *   }\n * }\n * ```\n *\n * @param {number} maximum The maximum value allowed\n * @param {boolean} exclusive Same effect as ExclusiveMaximum decorator.\n * @decorator\n * @validation\n * @swagger\n * @schema\n * @input\n */\nexport function Maximum(maximum: number, exclusive: boolean = false) {\n  return JsonEntityFn((store) => {\n    exclusive ? store.itemSchema.exclusiveMaximum(maximum) : store.itemSchema.maximum(maximum);\n  });\n}\n/**\n * The value of `maximum` MUST be a number, representing an inclusive upper limit for a numeric instance.\n *\n * If the instance is a number, then this keyword validates only if the instance is less than or exactly equal to `maximum`.\n *\n * ::: warning\n * For v6 user, use @@Maximum@@ from @tsed/schema instead of @tsed/common.\n * :::\n *\n * ## Example\n * ### With primitive type\n *\n * ```typescript\n * class Model {\n *    @Max(10)\n *    property: number;\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"properties\": {\n *     \"property\": {\n *       \"type\": \"number\",\n *       \"maximum\": 10\n *     }\n *   }\n * }\n * ```\n *\n * ### With array type\n *\n * ```typescript\n * class Model {\n *    @Max(10)\n *    @CollectionOf(Number)\n *    property: number[];\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"properties\": {\n *     \"property\": {\n *       \"type\": \"array\",\n *       \"items\": {\n *          \"type\": \"number\",\n *          \"maximum\": 10\n *       }\n *     }\n *   }\n * }\n * ```\n *\n * @param {number} maximum The maximum value allowed\n * @param {boolean} exclusive Same effect as ExclusiveMaximum decorator.\n * @decorator\n * @validation\n * @swagger\n * @schema\n * @input\n */\nexport function Max(maximum: number, exclusive: boolean = false) {\n  return Maximum(maximum, exclusive);\n}\n"]}

package/lib/cjs/decorators/common/minLength.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MinLength = void 0;
+const jsonEntityFn_1 = require("./jsonEntityFn");
+/**
+ *
+ * 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/common.
+ * :::
+ *
+ * ## 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
+ */
+function MinLength(minLength) {
+    if (minLength < 0) {
+        throw new Error("The value of minLength MUST be a non-negative integer.");
+    }
+    return (0, jsonEntityFn_1.JsonEntityFn)((store) => {
+        store.itemSchema.minLength(minLength);
+    });
+}
+exports.MinLength = MinLength;
+//# sourceMappingURL=minLength.js.map

package/lib/cjs/decorators/common/minLength.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"minLength.js","sourceRoot":"","sources":["../../../../src/decorators/common/minLength.ts"],"names":[],"mappings":";;;AAAA,iDAA4C;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2EG;AACH,SAAgB,SAAS,CAAC,SAAiB;IACzC,IAAI,SAAS,GAAG,CAAC,EAAE;QACjB,MAAM,IAAI,KAAK,CAAC,wDAAwD,CAAC,CAAC;KAC3E;IAED,OAAO,IAAA,2BAAY,EAAC,CAAC,KAAK,EAAE,EAAE;QAC5B,KAAK,CAAC,UAAU,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;IACxC,CAAC,CAAC,CAAC;AACL,CAAC;AARD,8BAQC","sourcesContent":["import {JsonEntityFn} from \"./jsonEntityFn\";\n\n/**\n *\n * A string instance is valid against this keyword if its length is greater than, or equal to, the value of this keyword.\n *\n * 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).\n *\n * ::: warning\n * The value of minLength MUST be a non-negative integer.\n * :::\n *\n * ::: tip\n * Omitting this keyword has the same behavior as a value of 0.\n * :::\n *\n * ::: warning\n * For v6 user, use @@MinLength@@ from @tsed/schema instead of @tsed/common.\n * :::\n *\n * ## Example\n * ### With primitive type\n *\n * ```typescript\n * class Model {\n *    @MinLength(10)\n *    property: number;\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"properties\": {\n *     \"property\": {\n *       \"type\": \"string\",\n *       \"maxLength\": 10\n *     }\n *   }\n * }\n * ```\n *\n * ### With array type\n *\n * ```typescript\n * class Model {\n *    @MinLength(10)\n *    @CollectionOf(String)\n *    property: string[];\n * }\n * ```\n *\n * Will produce:\n *\n * ```json\n * {\n *   \"type\": \"object\",\n *   \"properties\": {\n *     \"property\": {\n *       \"type\": \"array\",\n *       \"items\": {\n *          \"type\": \"string\",\n *          \"minLength\": 10\n *       }\n *     }\n *   }\n * }\n * ```\n *\n * @param {number} minLength\n * @decorator\n * @validation\n * @swagger\n * @schema\n * @input\n */\nexport function MinLength(minLength: number) {\n  if (minLength < 0) {\n    throw new Error(\"The value of minLength MUST be a non-negative integer.\");\n  }\n\n  return JsonEntityFn((store) => {\n    store.itemSchema.minLength(minLength);\n  });\n}\n"]}