@tsed/schema 7.0.0-alpha.1 → 7.0.0-beta.10

package/lib/cjs/decorators/operations/route.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Options = exports.Patch = exports.Head = exports.Delete = exports.Put = exports.Post = exports.Get = exports.All = exports.Route = void 0;
+const DecoratorContext_1 = require("../../domain/DecoratorContext");
+const mapRouteOptions_1 = require("../../utils/mapRouteOptions");
+const httpMethods_1 = require("../../constants/httpMethods");
+class RouteDecoratorContext extends DecoratorContext_1.DecoratorContext {
+    constructor() {
+        super(...arguments);
+        this.methods = ["name", "description", "summary", "method", "id", "use", "useAfter", "useBefore"];
+    }
+    beforeInit() {
+        const path = this.get("path");
+        const method = httpMethods_1.OperationMethods[this.get("method")] || httpMethods_1.OperationMethods.CUSTOM;
+        path && this.entity.operation.addOperationPath(method, path);
+    }
+    onMapKey(key, value) {
+        switch (key) {
+            case "name":
+            case "id":
+                this.entity.operation.operationId(value);
+                return;
+            case "summary":
+                this.entity.operation.summary(value);
+                return;
+            case "description":
+                this.entity.operation.description(value);
+                return;
+            case "use":
+                this.entity.use(value);
+                return;
+            case "useAfter":
+                this.entity.after(value);
+                return;
+            case "useBefore":
+                this.entity.before(value);
+                return;
+        }
+        return super.onMapKey(key, value);
+    }
+}
+function Route(...args) {
+    const routeOptions = (0, mapRouteOptions_1.mapRouteOptions)(args);
+    const context = new RouteDecoratorContext(routeOptions);
+    return context.build();
+}
+exports.Route = Route;
+/**
+ * This method is just like the `router.METHOD()` methods, except that it matches all HTTP methods (verbs).
+ *
+ * This method is extremely useful for mapping “global” logic for specific path prefixes or arbitrary matches.
+ * For example, if you placed the following route at the top of all other route definitions, it would require that
+ * all routes from that point on would require authentication, and automatically load a user.
+ * Keep in mind that these callbacks do not have to act as end points; loadUser can perform a task, then call next()
+ * to continue matching subsequent routes.
+ * @param path
+ * @param args
+ * @returns {Function}
+ * @decorator
+ * @operation
+ * @httpMethod
+ */
+function All(path = "/", ...args) {
+    return Route(...[httpMethods_1.OperationMethods.ALL, path].concat(args));
+}
+exports.All = All;
+/**
+ * This method is just like the `router.METHOD()` methods, except that it matches all HTTP methods (verbs).
+ *
+ * This method is extremely useful for mapping “global” logic for specific path prefixes or arbitrary matches.
+ * For example, if you placed the following route at the top of all other route definitions, it would require that
+ * all routes from that point on would require authentication, and automatically load a user.
+ * Keep in mind that these callbacks do not have to act as end points; loadUser can perform a task, then call next()
+ * to continue matching subsequent routes.
+ * @param path
+ * @param args
+ * @returns {Function}
+ * @decorator
+ * @operation
+ * @httpMethod
+ */
+function Get(path = "/", ...args) {
+    return Route(...[httpMethods_1.OperationMethods.GET, path].concat(args));
+}
+exports.Get = Get;
+/**
+ * This method is just like the `router.METHOD()` methods, except that it matches all HTTP methods (verbs).
+ *
+ * This method is extremely useful for mapping “global” logic for specific path prefixes or arbitrary matches.
+ * For example, if you placed the following route at the top of all other route definitions, it would require that
+ * all routes from that point on would require authentication, and automatically load a user.
+ * Keep in mind that these callbacks do not have to act as end points; loadUser can perform a task, then call next()
+ * to continue matching subsequent routes.
+ * @param path
+ * @param args
+ * @returns {Function}
+ * @decorator
+ * @operation
+ * @httpMethod
+ */
+function Post(path = "/", ...args) {
+    return Route(...[httpMethods_1.OperationMethods.POST, path].concat(args));
+}
+exports.Post = Post;
+/**
+ * This method is just like the `router.METHOD()` methods, except that it matches all HTTP methods (verbs).
+ *
+ * This method is extremely useful for mapping “global” logic for specific path prefixes or arbitrary matches.
+ * For example, if you placed the following route at the top of all other route definitions, it would require that
+ * all routes from that point on would require authentication, and automatically load a user.
+ * Keep in mind that these callbacks do not have to act as end points; loadUser can perform a task, then call next()
+ * to continue matching subsequent routes.
+ * @param path
+ * @param args
+ * @returns {Function}
+ * @decorator
+ * @operation
+ * @httpMethod
+ */
+function Put(path = "/", ...args) {
+    return Route(...[httpMethods_1.OperationMethods.PUT, path].concat(args));
+}
+exports.Put = Put;
+/**
+ * This method is just like the `router.METHOD()` methods, except that it matches all HTTP methods (verbs).
+ *
+ * This method is extremely useful for mapping “global” logic for specific path prefixes or arbitrary matches.
+ * For example, if you placed the following route at the top of all other route definitions, it would require that
+ * all routes from that point on would require authentication, and automatically load a user.
+ * Keep in mind that these callbacks do not have to act as end points; loadUser can perform a task, then call next()
+ * to continue matching subsequent routes.
+ * @param path
+ * @param args
+ * @returns {Function}
+ * @decorator
+ * @operation
+ * @httpMethod
+ */
+function Delete(path = "/", ...args) {
+    return Route(...[httpMethods_1.OperationMethods.DELETE, path].concat(args));
+}
+exports.Delete = Delete;
+/**
+ * This method is just like the `router.METHOD()` methods, except that it matches all HTTP methods (verbs).
+ *
+ * This method is extremely useful for mapping “global” logic for specific path prefixes or arbitrary matches.
+ * For example, if you placed the following route at the top of all other route definitions, it would require that
+ * all routes from that point on would require authentication, and automatically load a user.
+ * Keep in mind that these callbacks do not have to act as end points; loadUser can perform a task, then call next()
+ * to continue matching subsequent routes.
+ * @param path
+ * @param args
+ * @returns {Function}
+ * @decorator
+ * @operation
+ * @httpMethod
+ */
+function Head(path = "/", ...args) {
+    return Route(...[httpMethods_1.OperationMethods.HEAD, path].concat(args));
+}
+exports.Head = Head;
+/**
+ * This method is just like the `router.METHOD()` methods, except that it matches all HTTP methods (verbs).
+ *
+ * This method is extremely useful for mapping “global” logic for specific path prefixes or arbitrary matches.
+ * For example, if you placed the following route at the top of all other route definitions, it would require that
+ * all routes from that point on would require authentication, and automatically load a user.
+ * Keep in mind that these callbacks do not have to act as end points; loadUser can perform a task, then call next()
+ * to continue matching subsequent routes.
+ * @param path
+ * @param args
+ * @returns {Function}
+ * @decorator
+ * @operation
+ * @httpMethod
+ */
+function Patch(path = "/", ...args) {
+    return Route(...[httpMethods_1.OperationMethods.PATCH, path].concat(args));
+}
+exports.Patch = Patch;
+/**
+ * This method is just like the `router.METHOD()` methods, except that it matches all HTTP methods (verbs).
+ *
+ * This method is extremely useful for mapping “global” logic for specific path prefixes or arbitrary matches.
+ * For example, if you placed the following route at the top of all other route definitions, it would require that
+ * all routes from that point on would require authentication, and automatically load a user.
+ * Keep in mind that these callbacks do not have to act as end points; loadUser can perform a task, then call next()
+ * to continue matching subsequent routes.
+ * @param path
+ * @param args
+ * @returns {Function}
+ * @decorator
+ * @operation
+ * @httpMethod
+ */
+function Options(path = "/", ...args) {
+    return Route(...[httpMethods_1.OperationMethods.OPTIONS, path].concat(args));
+}
+exports.Options = Options;
+//# sourceMappingURL=route.js.map

package/lib/cjs/decorators/operations/route.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.js","sourceRoot":"","sources":["../../../../src/decorators/operations/route.ts"],"names":[],"mappings":";;;AAAA,oEAA+D;AAC/D,iEAA4D;AAC5D,6DAA6D;AAkD7D,MAAM,qBAAsB,SAAQ,mCAAwC;IAA5E;;QACW,YAAO,GAAa,CAAC,MAAM,EAAE,aAAa,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE,WAAW,CAAC,CAAC;IAmClH,CAAC;IAhCW,UAAU;QAClB,MAAM,IAAI,GAAW,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACtC,MAAM,MAAM,GAAW,8BAAgB,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAqB,CAAC,IAAI,8BAAgB,CAAC,MAAM,CAAC;QAE3G,IAAI,IAAI,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,gBAAgB,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IAC/D,CAAC;IAES,QAAQ,CAAC,GAAW,EAAE,KAAU;QACxC,QAAQ,GAAG,EAAE;YACX,KAAK,MAAM,CAAC;YACZ,KAAK,IAAI;gBACP,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;gBACzC,OAAO;YACT,KAAK,SAAS;gBACZ,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;gBACrC,OAAO;YACT,KAAK,aAAa;gBAChB,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;gBACzC,OAAO;YACT,KAAK,KAAK;gBACR,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;gBACvB,OAAO;YACT,KAAK,UAAU;gBACb,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;gBACzB,OAAO;YACT,KAAK,WAAW;gBACd,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;gBAC1B,OAAO;SACV;QAED,OAAO,KAAK,CAAC,QAAQ,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IACpC,CAAC;CACF;AAwBD,SAAgB,KAAK,CAAC,GAAG,IAAW;IAClC,MAAM,YAAY,GAAG,IAAA,iCAAe,EAAC,IAAI,CAAC,CAAC;IAE3C,MAAM,OAAO,GAAG,IAAI,qBAAqB,CAAC,YAAY,CAAC,CAAC;IAExD,OAAO,OAAO,CAAC,KAAK,EAAE,CAAC;AACzB,CAAC;AAND,sBAMC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAgB,GAAG,CAAC,OAA8B,GAAG,EAAE,GAAG,IAAW;IACnE,OAAO,KAAK,CAAC,GAAG,CAAC,8BAAgB,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;AAC7D,CAAC;AAFD,kBAEC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAgB,GAAG,CAAC,OAA8B,GAAG,EAAE,GAAG,IAAW;IACnE,OAAO,KAAK,CAAC,GAAG,CAAC,8BAAgB,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;AAC7D,CAAC;AAFD,kBAEC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAgB,IAAI,CAAC,OAA8B,GAAG,EAAE,GAAG,IAAW;IACpE,OAAO,KAAK,CAAC,GAAG,CAAC,8BAAgB,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;AAC9D,CAAC;AAFD,oBAEC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAgB,GAAG,CAAC,OAA8B,GAAG,EAAE,GAAG,IAAW;IACnE,OAAO,KAAK,CAAC,GAAG,CAAC,8BAAgB,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;AAC7D,CAAC;AAFD,kBAEC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAgB,MAAM,CAAC,OAA8B,GAAG,EAAE,GAAG,IAAW;IACtE,OAAO,KAAK,CAAC,GAAG,CAAC,8BAAgB,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;AAChE,CAAC;AAFD,wBAEC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAgB,IAAI,CAAC,OAA8B,GAAG,EAAE,GAAG,IAAW;IACpE,OAAO,KAAK,CAAC,GAAG,CAAC,8BAAgB,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;AAC9D,CAAC;AAFD,oBAEC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAgB,KAAK,CAAC,OAA8B,GAAG,EAAE,GAAG,IAAW;IACrE,OAAO,KAAK,CAAC,GAAG,CAAC,8BAAgB,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;AAC/D,CAAC;AAFD,sBAEC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAgB,OAAO,CAAC,OAA8B,GAAG,EAAE,GAAG,IAAW;IACvE,OAAO,KAAK,CAAC,GAAG,CAAC,8BAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;AACjE,CAAC;AAFD,0BAEC","sourcesContent":["import {DecoratorContext} from \"../../domain/DecoratorContext\";\nimport {mapRouteOptions} from \"../../utils/mapRouteOptions\";\nimport {OperationMethods} from \"../../constants/httpMethods\";\nimport {JsonMethodStore} from \"../../domain/JsonMethodStore\";\n\nexport interface RouteChainedDecorators {\n  <T>(target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<T>): TypedPropertyDescriptor<T> | void;\n\n  /**\n   * @param string\n   * @constructor\n   */\n  Path(string: string): this;\n\n  /**\n   * Set the operation method\n   * @param method\n   */\n  Method(method: OperationMethods | string): this;\n\n  /**\n   * Set the operation id\n   * @param id\n   */\n  Id(id: string): this;\n\n  /**\n   * Set the operation id\n   * @param name\n   */\n  Name(name: string): this;\n\n  /**\n   *\n   * @param description\n   */\n  Description(description: string): this;\n\n  /**\n   * Summary\n   * @constructor\n   * @param Summary\n   */\n  Summary(Summary: string): this;\n\n  Use(...args: any[]): this;\n\n  UseAfter(...args: any[]): this;\n\n  UseBefore(...args: any[]): this;\n}\n\nclass RouteDecoratorContext extends DecoratorContext<RouteChainedDecorators> {\n  readonly methods: string[] = [\"name\", \"description\", \"summary\", \"method\", \"id\", \"use\", \"useAfter\", \"useBefore\"];\n  protected entity: JsonMethodStore;\n\n  protected beforeInit() {\n    const path: string = this.get(\"path\");\n    const method: string = OperationMethods[this.get(\"method\") as OperationMethods] || OperationMethods.CUSTOM;\n\n    path && this.entity.operation.addOperationPath(method, path);\n  }\n\n  protected onMapKey(key: string, value: any) {\n    switch (key) {\n      case \"name\":\n      case \"id\":\n        this.entity.operation.operationId(value);\n        return;\n      case \"summary\":\n        this.entity.operation.summary(value);\n        return;\n      case \"description\":\n        this.entity.operation.description(value);\n        return;\n      case \"use\":\n        this.entity.use(value);\n        return;\n      case \"useAfter\":\n        this.entity.after(value);\n        return;\n      case \"useBefore\":\n        this.entity.before(value);\n        return;\n    }\n\n    return super.onMapKey(key, value);\n  }\n}\n\n/**\n * Describe a new route with a method and path.\n *\n * ```typescript\n * @Controller('/')\n * export class Ctrl {\n *\n *    @Route('GET', '/')\n *    get() { }\n * }\n *\n * ```\n *\n * @returns {Function}\n * @param method\n * @param path\n * @param args\n * @decorator\n * @operation\n */\nexport function Route(method: string, path: string, ...args: any[]): RouteChainedDecorators;\nexport function Route(...args: any[]): RouteChainedDecorators;\nexport function Route(...args: any[]): RouteChainedDecorators {\n  const routeOptions = mapRouteOptions(args);\n\n  const context = new RouteDecoratorContext(routeOptions);\n\n  return context.build();\n}\n\n/**\n * This method is just like the `router.METHOD()` methods, except that it matches all HTTP methods (verbs).\n *\n * This method is extremely useful for mapping “global” logic for specific path prefixes or arbitrary matches.\n * For example, if you placed the following route at the top of all other route definitions, it would require that\n * all routes from that point on would require authentication, and automatically load a user.\n * Keep in mind that these callbacks do not have to act as end points; loadUser can perform a task, then call next()\n * to continue matching subsequent routes.\n * @param path\n * @param args\n * @returns {Function}\n * @decorator\n * @operation\n * @httpMethod\n */\nexport function All(path: string | RegExp | any = \"/\", ...args: any[]) {\n  return Route(...[OperationMethods.ALL, path].concat(args));\n}\n\n/**\n * This method is just like the `router.METHOD()` methods, except that it matches all HTTP methods (verbs).\n *\n * This method is extremely useful for mapping “global” logic for specific path prefixes or arbitrary matches.\n * For example, if you placed the following route at the top of all other route definitions, it would require that\n * all routes from that point on would require authentication, and automatically load a user.\n * Keep in mind that these callbacks do not have to act as end points; loadUser can perform a task, then call next()\n * to continue matching subsequent routes.\n * @param path\n * @param args\n * @returns {Function}\n * @decorator\n * @operation\n * @httpMethod\n */\nexport function Get(path: string | RegExp | any = \"/\", ...args: any[]) {\n  return Route(...[OperationMethods.GET, path].concat(args));\n}\n\n/**\n * This method is just like the `router.METHOD()` methods, except that it matches all HTTP methods (verbs).\n *\n * This method is extremely useful for mapping “global” logic for specific path prefixes or arbitrary matches.\n * For example, if you placed the following route at the top of all other route definitions, it would require that\n * all routes from that point on would require authentication, and automatically load a user.\n * Keep in mind that these callbacks do not have to act as end points; loadUser can perform a task, then call next()\n * to continue matching subsequent routes.\n * @param path\n * @param args\n * @returns {Function}\n * @decorator\n * @operation\n * @httpMethod\n */\nexport function Post(path: string | RegExp | any = \"/\", ...args: any[]) {\n  return Route(...[OperationMethods.POST, path].concat(args));\n}\n\n/**\n * This method is just like the `router.METHOD()` methods, except that it matches all HTTP methods (verbs).\n *\n * This method is extremely useful for mapping “global” logic for specific path prefixes or arbitrary matches.\n * For example, if you placed the following route at the top of all other route definitions, it would require that\n * all routes from that point on would require authentication, and automatically load a user.\n * Keep in mind that these callbacks do not have to act as end points; loadUser can perform a task, then call next()\n * to continue matching subsequent routes.\n * @param path\n * @param args\n * @returns {Function}\n * @decorator\n * @operation\n * @httpMethod\n */\nexport function Put(path: string | RegExp | any = \"/\", ...args: any[]) {\n  return Route(...[OperationMethods.PUT, path].concat(args));\n}\n\n/**\n * This method is just like the `router.METHOD()` methods, except that it matches all HTTP methods (verbs).\n *\n * This method is extremely useful for mapping “global” logic for specific path prefixes or arbitrary matches.\n * For example, if you placed the following route at the top of all other route definitions, it would require that\n * all routes from that point on would require authentication, and automatically load a user.\n * Keep in mind that these callbacks do not have to act as end points; loadUser can perform a task, then call next()\n * to continue matching subsequent routes.\n * @param path\n * @param args\n * @returns {Function}\n * @decorator\n * @operation\n * @httpMethod\n */\nexport function Delete(path: string | RegExp | any = \"/\", ...args: any[]) {\n  return Route(...[OperationMethods.DELETE, path].concat(args));\n}\n\n/**\n * This method is just like the `router.METHOD()` methods, except that it matches all HTTP methods (verbs).\n *\n * This method is extremely useful for mapping “global” logic for specific path prefixes or arbitrary matches.\n * For example, if you placed the following route at the top of all other route definitions, it would require that\n * all routes from that point on would require authentication, and automatically load a user.\n * Keep in mind that these callbacks do not have to act as end points; loadUser can perform a task, then call next()\n * to continue matching subsequent routes.\n * @param path\n * @param args\n * @returns {Function}\n * @decorator\n * @operation\n * @httpMethod\n */\nexport function Head(path: string | RegExp | any = \"/\", ...args: any[]) {\n  return Route(...[OperationMethods.HEAD, path].concat(args));\n}\n\n/**\n * This method is just like the `router.METHOD()` methods, except that it matches all HTTP methods (verbs).\n *\n * This method is extremely useful for mapping “global” logic for specific path prefixes or arbitrary matches.\n * For example, if you placed the following route at the top of all other route definitions, it would require that\n * all routes from that point on would require authentication, and automatically load a user.\n * Keep in mind that these callbacks do not have to act as end points; loadUser can perform a task, then call next()\n * to continue matching subsequent routes.\n * @param path\n * @param args\n * @returns {Function}\n * @decorator\n * @operation\n * @httpMethod\n */\nexport function Patch(path: string | RegExp | any = \"/\", ...args: any[]) {\n  return Route(...[OperationMethods.PATCH, path].concat(args));\n}\n\n/**\n * This method is just like the `router.METHOD()` methods, except that it matches all HTTP methods (verbs).\n *\n * This method is extremely useful for mapping “global” logic for specific path prefixes or arbitrary matches.\n * For example, if you placed the following route at the top of all other route definitions, it would require that\n * all routes from that point on would require authentication, and automatically load a user.\n * Keep in mind that these callbacks do not have to act as end points; loadUser can perform a task, then call next()\n * to continue matching subsequent routes.\n * @param path\n * @param args\n * @returns {Function}\n * @decorator\n * @operation\n * @httpMethod\n */\nexport function Options(path: string | RegExp | any = \"/\", ...args: any[]) {\n  return Route(...[OperationMethods.OPTIONS, path].concat(args));\n}\n"]}

package/lib/cjs/decorators/operations/security.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Security = void 0;
+const core_1 = require("@tsed/core");
+const jsonEntityFn_1 = require("../common/jsonEntityFn");
+/**
+ * Add security metadata on the decorated method.
+ *
+ * ## Examples
+ * ### On method
+ *
+ * ```typescript
+ * @Controller("/")
+ * class ModelCtrl {
+ *    @Security("write:calendars")
+ *    async method() {}
+ * }
+ * ```
+ *
+ * @param name
+ * @param scopes
+ * @decorator
+ * @swagger
+ * @schema
+ * @classDecorator
+ * @operation
+ */
+function Security(name, ...scopes) {
+    return (0, jsonEntityFn_1.JsonEntityFn)((store, args) => {
+        switch (store.decoratorType) {
+            case core_1.DecoratorTypes.METHOD:
+                store.operation.addSecurityScopes(name, scopes);
+                break;
+            case core_1.DecoratorTypes.CLASS:
+                (0, core_1.decorateMethodsOf)(args[0], Security(name, ...scopes));
+                break;
+            default:
+                throw new core_1.UnsupportedDecoratorType(Security, args);
+        }
+    });
+}
+exports.Security = Security;
+//# sourceMappingURL=security.js.map

package/lib/cjs/decorators/operations/security.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"security.js","sourceRoot":"","sources":["../../../../src/decorators/operations/security.ts"],"names":[],"mappings":";;;AAAA,qCAAuF;AACvF,yDAAoD;AAEpD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,SAAgB,QAAQ,CAAC,IAAY,EAAE,GAAG,MAAgB;IACxD,OAAO,IAAA,2BAAY,EAAC,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE;QAClC,QAAQ,KAAK,CAAC,aAAa,EAAE;YAC3B,KAAK,qBAAc,CAAC,MAAM;gBACxB,KAAK,CAAC,SAAU,CAAC,iBAAiB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;gBACjD,MAAM;YACR,KAAK,qBAAc,CAAC,KAAK;gBACvB,IAAA,wBAAiB,EAAC,IAAI,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC;gBACtD,MAAM;YAER;gBACE,MAAM,IAAI,+BAAwB,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;SACtD;IACH,CAAC,CAAC,CAAC;AACL,CAAC;AAdD,4BAcC","sourcesContent":["import {decorateMethodsOf, DecoratorTypes, UnsupportedDecoratorType} from \"@tsed/core\";\nimport {JsonEntityFn} from \"../common/jsonEntityFn\";\n\n/**\n * Add security metadata on the decorated method.\n *\n * ## Examples\n * ### On method\n *\n * ```typescript\n * @Controller(\"/\")\n * class ModelCtrl {\n *    @Security(\"write:calendars\")\n *    async method() {}\n * }\n * ```\n *\n * @param name\n * @param scopes\n * @decorator\n * @swagger\n * @schema\n * @classDecorator\n * @operation\n */\nexport function Security(name: string, ...scopes: string[]) {\n  return JsonEntityFn((store, args) => {\n    switch (store.decoratorType) {\n      case DecoratorTypes.METHOD:\n        store.operation!.addSecurityScopes(name, scopes);\n        break;\n      case DecoratorTypes.CLASS:\n        decorateMethodsOf(args[0], Security(name, ...scopes));\n        break;\n\n      default:\n        throw new UnsupportedDecoratorType(Security, args);\n    }\n  });\n}\n"]}

package/lib/cjs/decorators/operations/status.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Status = void 0;
+const returns_1 = require("./returns");
+/**
+ * Add responses documentation for a specific status code.
+ *
+ * ## Usage
+ *
+ * Ts.ED v6 API introducing the chaining decorator concept.
+ * Now a decorator like Returns can be used with another decorators like Description.
+ *
+ * ```typescript
+ * import {Returns} from "@tsed/schema";
+ *
+ * @Controller("/")
+ * class MyController {
+ *   @Status(404, String).Description("Not Found")
+ *   @Status(200, Model).Description("Success")
+ *   async myMethod(): Promise<Model> {}
+ * }
+ * ```
+ *
+ * ::: tip
+ * TypeScript and your IDE will discover automatically the chained decorators. But for more details you can look on @@ReturnsChainedDecorators@@ interface, to know
+ * what chained decorators are available under Returns decorator.
+ * :::
+ *
+ * This example will produce this documentation in swagger:
+ *
+ * ```json
+ * {
+ *   "responses": {
+ *     "404": {
+ *       "description": "Description",
+ *       "schema": {"type": "string"}
+ *     },
+ *     "2OO": {
+ *       "description": "Description",
+ *       "schema": {"$ref": "..."}
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * ### Declaring a generic model
+ *
+ * Sometime, it might be useful to use generic models. TypeScript doesn't store the generic type in the metadata. This is why we need to
+ * declare explicitly the generic models with the decorators.
+ *
+ * One of the generic's usage, can be a paginated list. With Returns decorator it's now possible to declare generic type and generate the appropriate OpenSpec documentation.
+ *
+ * Starting with the pagination model, by using @@Generics@@ and @@CollectionOf@@:
+ *
+ * ```typescript
+ * @Generics("T")
+ * class Pagination<T> {
+ *  @CollectionOf("T")
+ *  data: T[];
+ *
+ *  @Property()
+ *  totalCount: number;
+ * }
+ * ```
+ *
+ * Now, we need a model to be used with the generic Pagination model:
+ *
+ * ```typescript
+ * class Product {
+ *  @Property()
+ *  id: string;
+ *
+ *  @Property()
+ *  title: string;
+ * }
+ * ```
+ *
+ * Finally, we can use our models on a method as following:
+ *
+ * ```typescript
+ * class Controller {
+ *   @OperationPath("POST", "/")
+ *   @Status(200, Pagination).Of(Product).Description("description")
+ *   async method(): Promise<Pagination<Product> | null> {
+ *     return null;
+ *   }
+ * }
+ * ```
+ *
+ * ### Declaring a nested generics models <Badge text="6+"/>
+ *
+ * It's also possible to declare a nested generics models in order to have this type `Pagination<Submission<Product>>`:
+ *
+ * ```typescript
+ * import {Generics, Property, Returns} from "@tsed/schema";
+ * import {Post} from "@tsed/common";
+ *
+ * class Controller {
+ *   @Post("/")
+ *   @Status(200, Pagination).Of(Submission).Nested(Product).Description("description")
+ *   async method(): Promise<Pagination<Submission<Product>> | null> {
+ *     return null;
+ *   }
+ * }
+ * ```
+ *
+ * And here is the Submission model:
+ *
+ * ```typescript
+ * import {Generics, Property} from "@tsed/schema";
+ *
+ * @Generics("T")
+ * class Submission<T> {
+ *   @Property()
+ *   _id: string;
+ *   @Property("T")
+ *   data: T;
+ * }
+ * ```
+ *
+ * @param status
+ * @param model
+ * @decorator
+ * @swagger
+ * @schema
+ * @response
+ * @operation
+ */
+function Status(status, model) {
+    return (0, returns_1.Returns)(status, model);
+}
+exports.Status = Status;
+//# sourceMappingURL=status.js.map

package/lib/cjs/decorators/operations/status.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.js","sourceRoot":"","sources":["../../../../src/decorators/operations/status.ts"],"names":[],"mappings":";;;AACA,uCAA4D;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2HG;AACH,SAAgB,MAAM,CAAC,MAAuB,EAAE,KAAuB;IACrE,OAAO,IAAA,iBAAO,EAAC,MAAM,EAAE,KAAK,CAAC,CAAC;AAChC,CAAC;AAFD,wBAEC","sourcesContent":["import {Type} from \"@tsed/core\";\nimport {Returns, ReturnsChainedDecorators} from \"./returns\";\n\n/**\n * Add responses documentation for a specific status code.\n *\n * ## Usage\n *\n * Ts.ED v6 API introducing the chaining decorator concept.\n * Now a decorator like Returns can be used with another decorators like Description.\n *\n * ```typescript\n * import {Returns} from \"@tsed/schema\";\n *\n * @Controller(\"/\")\n * class MyController {\n *   @Status(404, String).Description(\"Not Found\")\n *   @Status(200, Model).Description(\"Success\")\n *   async myMethod(): Promise<Model> {}\n * }\n * ```\n *\n * ::: tip\n * TypeScript and your IDE will discover automatically the chained decorators. But for more details you can look on @@ReturnsChainedDecorators@@ interface, to know\n * what chained decorators are available under Returns decorator.\n * :::\n *\n * This example will produce this documentation in swagger:\n *\n * ```json\n * {\n *   \"responses\": {\n *     \"404\": {\n *       \"description\": \"Description\",\n *       \"schema\": {\"type\": \"string\"}\n *     },\n *     \"2OO\": {\n *       \"description\": \"Description\",\n *       \"schema\": {\"$ref\": \"...\"}\n *     }\n *   }\n * }\n * ```\n *\n * ### Declaring a generic model\n *\n * Sometime, it might be useful to use generic models. TypeScript doesn't store the generic type in the metadata. This is why we need to\n * declare explicitly the generic models with the decorators.\n *\n * One of the generic's usage, can be a paginated list. With Returns decorator it's now possible to declare generic type and generate the appropriate OpenSpec documentation.\n *\n * Starting with the pagination model, by using @@Generics@@ and @@CollectionOf@@:\n *\n * ```typescript\n * @Generics(\"T\")\n * class Pagination<T> {\n *  @CollectionOf(\"T\")\n *  data: T[];\n *\n *  @Property()\n *  totalCount: number;\n * }\n * ```\n *\n * Now, we need a model to be used with the generic Pagination model:\n *\n * ```typescript\n * class Product {\n *  @Property()\n *  id: string;\n *\n *  @Property()\n *  title: string;\n * }\n * ```\n *\n * Finally, we can use our models on a method as following:\n *\n * ```typescript\n * class Controller {\n *   @OperationPath(\"POST\", \"/\")\n *   @Status(200, Pagination).Of(Product).Description(\"description\")\n *   async method(): Promise<Pagination<Product> | null> {\n *     return null;\n *   }\n * }\n * ```\n *\n * ### Declaring a nested generics models <Badge text=\"6+\"/>\n *\n * It's also possible to declare a nested generics models in order to have this type `Pagination<Submission<Product>>`:\n *\n * ```typescript\n * import {Generics, Property, Returns} from \"@tsed/schema\";\n * import {Post} from \"@tsed/common\";\n *\n * class Controller {\n *   @Post(\"/\")\n *   @Status(200, Pagination).Of(Submission).Nested(Product).Description(\"description\")\n *   async method(): Promise<Pagination<Submission<Product>> | null> {\n *     return null;\n *   }\n * }\n * ```\n *\n * And here is the Submission model:\n *\n * ```typescript\n * import {Generics, Property} from \"@tsed/schema\";\n *\n * @Generics(\"T\")\n * class Submission<T> {\n *   @Property()\n *   _id: string;\n *   @Property(\"T\")\n *   data: T;\n * }\n * ```\n *\n * @param status\n * @param model\n * @decorator\n * @swagger\n * @schema\n * @response\n * @operation\n */\nexport function Status(status: string | number, model?: Type<any> | any): ReturnsChainedDecorators {\n  return Returns(status, model);\n}\n"]}

package/lib/cjs/decorators/operations/summary.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Summary = void 0;
+const core_1 = require("@tsed/core");
+const jsonEntityFn_1 = require("../common/jsonEntityFn");
+/**
+ * Add summary metadata on the decorated element.
+ *
+ * ## Examples
+ * ### On method
+ *
+ * ```typescript
+ * class Model {
+ *    @Summary("summary")
+ *    id: string;
+ * }
+ * ```
+ *
+ * @param summary
+ * @decorator
+ * @swagger
+ * @schema
+ * @operation
+ */
+function Summary(summary) {
+    return (0, jsonEntityFn_1.JsonEntityFn)((store, args) => {
+        if (store.decoratorType !== core_1.DecoratorTypes.METHOD) {
+            throw new core_1.UnsupportedDecoratorType(Summary, args);
+        }
+        store.operation.summary(summary);
+    });
+}
+exports.Summary = Summary;
+//# sourceMappingURL=summary.js.map

package/lib/cjs/decorators/operations/summary.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"summary.js","sourceRoot":"","sources":["../../../../src/decorators/operations/summary.ts"],"names":[],"mappings":";;;AAAA,qCAAoE;AACpE,yDAAoD;AAEpD;;;;;;;;;;;;;;;;;;GAkBG;AACH,SAAgB,OAAO,CAAC,OAAe;IACrC,OAAO,IAAA,2BAAY,EAAC,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE;QAClC,IAAI,KAAK,CAAC,aAAa,KAAK,qBAAc,CAAC,MAAM,EAAE;YACjD,MAAM,IAAI,+BAAwB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;SACnD;QAED,KAAK,CAAC,SAAU,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IACpC,CAAC,CAAC,CAAC;AACL,CAAC;AARD,0BAQC","sourcesContent":["import {DecoratorTypes, UnsupportedDecoratorType} from \"@tsed/core\";\nimport {JsonEntityFn} from \"../common/jsonEntityFn\";\n\n/**\n * Add summary metadata on the decorated element.\n *\n * ## Examples\n * ### On method\n *\n * ```typescript\n * class Model {\n *    @Summary(\"summary\")\n *    id: string;\n * }\n * ```\n *\n * @param summary\n * @decorator\n * @swagger\n * @schema\n * @operation\n */\nexport function Summary(summary: string) {\n  return JsonEntityFn((store, args) => {\n    if (store.decoratorType !== DecoratorTypes.METHOD) {\n      throw new UnsupportedDecoratorType(Summary, args);\n    }\n\n    store.operation!.summary(summary);\n  });\n}\n"]}

package/lib/cjs/decorators/operations/tags.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tags = void 0;
+const core_1 = require("@tsed/core");
+const jsonEntityFn_1 = require("../common/jsonEntityFn");
+function mapTags(tags) {
+    return tags.map((tag) => {
+        if (typeof tag === "string") {
+            return {
+                name: tag
+            };
+        }
+        return tag;
+    });
+}
+/**
+ * Add tags metadata on the decorated element.
+ *
+ * ## Examples
+ * ### On method
+ *
+ * ```typescript
+ * @Controller("/")
+ * class MyController {
+ *  @Tags("api")
+ *  get() {}
+ * }
+ * ```
+ *
+ * @param tags
+ * @decorator
+ * @swagger
+ * @schema
+ * @classDecorator
+ * @operation
+ */
+function Tags(...tags) {
+    return (0, jsonEntityFn_1.JsonEntityFn)((store, args) => {
+        switch (store.decoratorType) {
+            case core_1.DecoratorTypes.METHOD:
+                store.operation.addTags(mapTags(tags));
+                break;
+            case core_1.DecoratorTypes.CLASS:
+                (0, core_1.decorateMethodsOf)(args[0], Tags(...tags));
+                break;
+            default:
+                throw new core_1.UnsupportedDecoratorType(Tags, args);
+        }
+    });
+}
+exports.Tags = Tags;
+//# sourceMappingURL=tags.js.map

package/lib/cjs/decorators/operations/tags.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tags.js","sourceRoot":"","sources":["../../../../src/decorators/operations/tags.ts"],"names":[],"mappings":";;;AAAA,qCAAuF;AAEvF,yDAAoD;AAEpD,SAAS,OAAO,CAAC,IAA8B;IAC7C,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE;QACtB,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE;YAC3B,OAAO;gBACL,IAAI,EAAE,GAAG;aACV,CAAC;SACH;QAED,OAAO,GAAG,CAAC;IACb,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,SAAgB,IAAI,CAAC,GAAG,IAA8B;IACpD,OAAO,IAAA,2BAAY,EAAC,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE;QAClC,QAAQ,KAAK,CAAC,aAAa,EAAE;YAC3B,KAAK,qBAAc,CAAC,MAAM;gBACxB,KAAK,CAAC,SAAU,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;gBACxC,MAAM;YACR,KAAK,qBAAc,CAAC,KAAK;gBACvB,IAAA,wBAAiB,EAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;gBAC1C,MAAM;YAER;gBACE,MAAM,IAAI,+BAAwB,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;SAClD;IACH,CAAC,CAAC,CAAC;AACL,CAAC;AAdD,oBAcC","sourcesContent":["import {decorateMethodsOf, DecoratorTypes, UnsupportedDecoratorType} from \"@tsed/core\";\nimport {OpenSpecTag} from \"@tsed/openspec\";\nimport {JsonEntityFn} from \"../common/jsonEntityFn\";\n\nfunction mapTags(tags: (string | OpenSpecTag)[]) {\n  return tags.map((tag) => {\n    if (typeof tag === \"string\") {\n      return {\n        name: tag\n      };\n    }\n\n    return tag;\n  });\n}\n\n/**\n * Add tags metadata on the decorated element.\n *\n * ## Examples\n * ### On method\n *\n * ```typescript\n * @Controller(\"/\")\n * class MyController {\n *  @Tags(\"api\")\n *  get() {}\n * }\n * ```\n *\n * @param tags\n * @decorator\n * @swagger\n * @schema\n * @classDecorator\n * @operation\n */\nexport function Tags(...tags: (string | OpenSpecTag)[]) {\n  return JsonEntityFn((store, args) => {\n    switch (store.decoratorType) {\n      case DecoratorTypes.METHOD:\n        store.operation!.addTags(mapTags(tags));\n        break;\n      case DecoratorTypes.CLASS:\n        decorateMethodsOf(args[0], Tags(...tags));\n        break;\n\n      default:\n        throw new UnsupportedDecoratorType(Tags, args);\n    }\n  });\n}\n"]}

package/lib/cjs/decorators/operations/view.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.View = void 0;
+const core_1 = require("@tsed/core");
+/**
+ * Use a view and sends the rendered HTML string to the client. Optional parameter:
+ *
+ * * viewOptions, an object whose properties define local variables for the view.
+ *
+ * The view argument is a string that is the file path of the view file to render.
+ * This can be an absolute path, or a path relative to the views setting.
+ * If the path does not contain a file extension, then the view engine setting determines the file extension.
+ * If the path does contain a file extension, then Express will load the module for the specified template engine (via require())
+ * and render it using the loaded module’s __express function.
+ *
+ * For more information, see [Using template engines with Express](http://expressjs.com/guide/using-template-engines.html).
+ *
+ * > NOTE: The view argument performs file system operations like reading a file from disk and evaluating Node.js modules,
+ * and as so for security reasons should not contain input from the end-user.
+ *
+ * @param path Relative path to the view file.
+ * @param options Additional options
+ * @decorator
+ * @operation
+ * @response
+ */
+function View(path, options) {
+    return (0, core_1.StoreSet)("view", { path, options });
+}
+exports.View = View;
+//# sourceMappingURL=view.js.map

package/lib/cjs/decorators/operations/view.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"view.js","sourceRoot":"","sources":["../../../../src/decorators/operations/view.ts"],"names":[],"mappings":";;;AAAA,qCAAoC;AAEpC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,SAAgB,IAAI,CAAC,IAAY,EAAE,OAAgB;IACjD,OAAO,IAAA,eAAQ,EAAC,MAAM,EAAE,EAAC,IAAI,EAAE,OAAO,EAAC,CAAQ,CAAC;AAClD,CAAC;AAFD,oBAEC","sourcesContent":["import {StoreSet} from \"@tsed/core\";\n\n/**\n * Use a view and sends the rendered HTML string to the client. Optional parameter:\n *\n * * viewOptions, an object whose properties define local variables for the view.\n *\n * The view argument is a string that is the file path of the view file to render.\n * This can be an absolute path, or a path relative to the views setting.\n * If the path does not contain a file extension, then the view engine setting determines the file extension.\n * If the path does contain a file extension, then Express will load the module for the specified template engine (via require())\n * and render it using the loaded module’s __express function.\n *\n * For more information, see [Using template engines with Express](http://expressjs.com/guide/using-template-engines.html).\n *\n * > NOTE: The view argument performs file system operations like reading a file from disk and evaluating Node.js modules,\n * and as so for security reasons should not contain input from the end-user.\n *\n * @param path Relative path to the view file.\n * @param options Additional options\n * @decorator\n * @operation\n * @response\n */\nexport function View(path: string, options?: Object): MethodDecorator {\n  return StoreSet(\"view\", {path, options}) as any;\n}\n"]}

package/lib/cjs/domain/DecoratorContext.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DecoratorContext = void 0;
+const core_1 = require("@tsed/core");
+const pascal_case_1 = require("pascal-case");
+const JsonEntityStore_1 = require("./JsonEntityStore");
+/**
+ * @ignore
+ */
+class DecoratorContext extends Map {
+    constructor(opts = {}) {
+        super();
+        this.actions = [];
+        Object.entries(opts).forEach(([key, value]) => {
+            this.set(key, value);
+        });
+    }
+    addAction(cb) {
+        this.actions.push(cb);
+        return this;
+    }
+    build() {
+        const decorator = (...args) => this.bind(args, decorator);
+        const wrap = (cb) => {
+            return (...args) => {
+                cb(...args);
+                return decorator;
+            };
+        };
+        const wrapKey = (key) => {
+            return wrap((...values) => {
+                key in this ? this[key](...values) : this.set(key, values[0]);
+            });
+        };
+        this.methods.forEach((name) => {
+            decorator[(0, pascal_case_1.pascalCase)(name)] = wrapKey(name);
+        });
+        return decorator;
+    }
+    toObject() {
+        return [...this.entries()].reduce((obj, [key, value]) => {
+            return {
+                ...obj,
+                [key]: value
+            };
+        }, {});
+    }
+    getMergedKey(key, defaultValue) {
+        let value = this.get(key) || defaultValue;
+        if (!value) {
+            return;
+        }
+        if (this.decoratorType === core_1.DecoratorTypes.CLASS) {
+            value = {
+                ...value,
+                ...(defaultValue || {})
+            };
+        }
+        return {
+            ...(defaultValue || {}),
+            ...value
+        };
+    }
+    bind(args, decorator) {
+        this.entity = JsonEntityStore_1.JsonEntityStore.from(...args);
+        this.beforeInit();
+        this.onInit(args, decorator);
+        this.afterInit();
+    }
+    onInit(args, decorator) {
+        this.forEach((value, key) => {
+            this.onMapKey(key, value);
+        });
+    }
+    onMapKey(key, value) {
+        this.entity.set(key, value);
+    }
+    runActions() {
+        this.actions.forEach((action) => {
+            action(this);
+        });
+        return this;
+    }
+    beforeInit() { }
+    afterInit() { }
+}
+exports.DecoratorContext = DecoratorContext;
+//# sourceMappingURL=DecoratorContext.js.map

package/lib/cjs/domain/DecoratorContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DecoratorContext.js","sourceRoot":"","sources":["../../../src/domain/DecoratorContext.ts"],"names":[],"mappings":"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","sourcesContent":["import {DecoratorParameters, DecoratorTypes} from \"@tsed/core\";\nimport {pascalCase} from \"pascal-case\";\nimport {JsonEntityStore} from \"./JsonEntityStore\";\n\n/**\n * @ignore\n */\nexport interface DecoratorActionHandler {\n  (ctx: Map<string, any>): void;\n}\n\n/**\n * @ignore\n */\nexport abstract class DecoratorContext<T = any> extends Map<string, any> {\n  readonly methods: string[];\n  protected decoratorType: DecoratorTypes;\n  protected entity: JsonEntityStore;\n  protected actions: DecoratorActionHandler[] = [];\n\n  constructor(opts: any = {}) {\n    super();\n\n    Object.entries(opts).forEach(([key, value]) => {\n      this.set(key, value);\n    });\n  }\n\n  addAction(cb: DecoratorActionHandler) {\n    this.actions.push(cb);\n    return this;\n  }\n\n  build(): T {\n    const decorator: any = (...args: DecoratorParameters) => this.bind(args, decorator);\n\n    const wrap = (cb: any) => {\n      return (...args: any[]) => {\n        cb(...args);\n        return decorator;\n      };\n    };\n\n    const wrapKey = (key: string) => {\n      return wrap((...values: any[]) => {\n        key in this ? (this as any)[key](...values) : this.set(key, values[0]);\n      });\n    };\n\n    this.methods.forEach((name) => {\n      decorator[pascalCase(name)] = wrapKey(name);\n    });\n\n    return decorator as unknown as T;\n  }\n\n  toObject(): any {\n    return [...this.entries()].reduce((obj, [key, value]) => {\n      return {\n        ...obj,\n        [key]: value\n      };\n    }, {});\n  }\n\n  getMergedKey(key: string, defaultValue: any) {\n    let value = this.get(key) || defaultValue;\n\n    if (!value) {\n      return;\n    }\n\n    if (this.decoratorType === DecoratorTypes.CLASS) {\n      value = {\n        ...value,\n        ...(defaultValue || {})\n      };\n    }\n\n    return {\n      ...(defaultValue || {}),\n      ...value\n    };\n  }\n\n  protected bind(args: DecoratorParameters, decorator: any) {\n    this.entity = JsonEntityStore.from(...args);\n\n    this.beforeInit();\n    this.onInit(args, decorator);\n    this.afterInit();\n  }\n\n  protected onInit(args: DecoratorParameters, decorator: any): void {\n    this.forEach((value, key) => {\n      this.onMapKey(key, value);\n    });\n  }\n\n  protected onMapKey(key: string, value: any): void {\n    this.entity.set(key, value);\n  }\n\n  protected runActions() {\n    this.actions.forEach((action: any) => {\n      action(this);\n    });\n\n    return this;\n  }\n\n  protected beforeInit() {}\n\n  protected afterInit() {}\n}\n"]}