@tsed/schema 6.72.3 → 6.73.3

package/lib/index.js

@@ -82,6 +82,21 @@ function getStatusMessage(status) {
   return HTTP_STATUS_MESSAGES[status];
 }
 
+const HTTP_METHODS = ["all", "checkout", "connect", "copy", "delete", "get", "head", "lock", "merge", "mkactivity", "mkcol", "move", "m-search", "notify", "options", "param", "patch", "post", "propfind", "propatch", "purge", "put", "report", "search", "subscribe", "trace", "unlock", "unsuscribe"];
+exports.OperationMethods = void 0;
+
+(function (OperationMethods) {
+  OperationMethods["ALL"] = "ALL";
+  OperationMethods["GET"] = "GET";
+  OperationMethods["POST"] = "POST";
+  OperationMethods["PUT"] = "PUT";
+  OperationMethods["PATCH"] = "PATCH";
+  OperationMethods["HEAD"] = "HEAD";
+  OperationMethods["DELETE"] = "DELETE";
+  OperationMethods["OPTIONS"] = "OPTIONS";
+  OperationMethods["CUSTOM"] = "CUSTOM";
+})(exports.OperationMethods || (exports.OperationMethods = {}));
+
 function _extends() {
   _extends = Object.assign || function (target) {
     for (var i = 1; i < arguments.length; i++) {
@@ -2152,10 +2167,10 @@ class JsonEntityStore extends core.Entity {
     return this.from(target, propertyKey, core.descriptorOf(target, propertyKey));
   }
 
-  getResponseOptions(contentType = "application/json") {
+  getResponseOptions(status, contentType = "application/json") {
     var _this$operation, _this$operation$getRe;
 
-    const media = (_this$operation = this.operation) == null ? void 0 : (_this$operation$getRe = _this$operation.getResponseOf(this.statusCode)) == null ? void 0 : _this$operation$getRe.getMedia(contentType, false);
+    const media = (_this$operation = this.operation) == null ? void 0 : (_this$operation$getRe = _this$operation.getResponseOf(status)) == null ? void 0 : _this$operation$getRe.getMedia(contentType, false);
 
     if (media && media.has("schema")) {
       const schema = media.get("schema");
@@ -2206,7 +2221,11 @@ class JsonEntityStore extends core.Entity {
       if (core.isCollection(type)) {
         this.collectionType = type;
       } else {
-        this._type = type;
+        this._type = type; // issue #1534: Enum metadata stored as plain object instead of String (see: https://github.com/tsedio/tsed/issues/1534)
+
+        if (this._type && core.isPlainObject(this._type)) {
+          this._type = String;
+        }
       }
     }
 
@@ -4248,9 +4267,12 @@ function Consumes(...consumes) {
  */
 
 class DecoratorContext extends Map {
-  constructor() {
-    super(...arguments);
+  constructor(opts = {}) {
+    super();
     this.actions = [];
+    Object.entries(opts).forEach(([key, value]) => {
+      this.set(key, value);
+    });
   }
 
   addAction(cb) {
@@ -4259,7 +4281,7 @@ class DecoratorContext extends Map {
   }
 
   build() {
-    const decorator = (...args) => this.onInit(args, decorator);
+    const decorator = (...args) => this.bind(args, decorator);
 
     const wrap = cb => {
       return (...args) => {
@@ -4302,6 +4324,24 @@ class DecoratorContext extends Map {
     return _extends({}, defaultValue || {}, value);
   }
 
+  bind(args, decorator) {
+    this.entity = JsonEntityStore.from(...args);
+    this.beforeInit();
+    this.onInit(args, decorator);
+    this.afterInit();
+    this.clear();
+  }
+
+  onInit(args, decorator) {
+    this.forEach((value, key) => {
+      this.onMapKey(key, value);
+    });
+  }
+
+  onMapKey(key, value) {
+    this.entity.store.set(key, value);
+  }
+
   runActions() {
     this.actions.forEach(action => {
       action(this);
@@ -4309,6 +4349,10 @@ class DecoratorContext extends Map {
     return this;
   }
 
+  beforeInit() {}
+
+  afterInit() {}
+
 }
 
 /**
@@ -4470,9 +4514,9 @@ class ReturnDecoratorContext extends DecoratorContext {
 
     switch (type) {
       case core.DecoratorTypes.METHOD:
-        this.store = JsonEntityStore.from(...args);
+        this.entity = JsonEntityStore.from(...args);
 
-        if (this.store.operation) {
+        if (this.entity.operation) {
           this.map();
         }
 
@@ -4493,10 +4537,10 @@ class ReturnDecoratorContext extends DecoratorContext {
   map() {
     const model = this.get("model");
     const {
-      store,
+      entity,
       decoratorType
     } = this;
-    const operation = this.store.operation;
+    const operation = this.entity.operation;
     const currentStatus = this.getStatus();
     const response = operation.ensureResponseOf(currentStatus);
     const contentType = this.getContentType();
@@ -4519,7 +4563,7 @@ class ReturnDecoratorContext extends DecoratorContext {
 
     if (isSuccessStatus(this.get("status")) || currentStatus === "default") {
       if (model) {
-        store.type = model;
+        entity.type = model;
       }
     } // additional info for OS2
 
@@ -4690,19 +4734,6 @@ function OperationId(operationId) {
   });
 }
 
-exports.OperationMethods = void 0;
-
-(function (OperationMethods) {
-  OperationMethods["ALL"] = "ALL";
-  OperationMethods["GET"] = "GET";
-  OperationMethods["POST"] = "POST";
-  OperationMethods["PUT"] = "PUT";
-  OperationMethods["PATCH"] = "PATCH";
-  OperationMethods["HEAD"] = "HEAD";
-  OperationMethods["DELETE"] = "DELETE";
-  OperationMethods["OPTIONS"] = "OPTIONS";
-  OperationMethods["CUSTOM"] = "CUSTOM";
-})(exports.OperationMethods || (exports.OperationMethods = {}));
 /**
  * Declare new Operation with his path and http method.
  *
@@ -4723,7 +4754,6 @@ exports.OperationMethods = void 0;
  * @operation
  */
 
-
 function OperationPath(method, path = "/") {
   return JsonEntityFn((store, args) => {
     if (store.decoratorType !== core.DecoratorTypes.METHOD) {
@@ -5231,6 +5261,228 @@ function Location(location, meta) {
   return Returns().Location(location, meta);
 }
 
+function mapRouteOptions(args) {
+  let method = undefined;
+  let path = undefined;
+  const handlers = args.filter(arg => {
+    if (typeof arg === "string" && HTTP_METHODS.includes(arg.toLowerCase())) {
+      method = arg.toLocaleUpperCase();
+      return false;
+    }
+
+    if (typeof arg === "string" || arg instanceof RegExp) {
+      path = arg || "/";
+      return false;
+    }
+
+    return !!arg;
+  });
+  return {
+    path,
+    method,
+    handlers
+  };
+}
+
+class RouteDecoratorContext extends DecoratorContext {
+  constructor() {
+    super(...arguments);
+    this.methods = ["name", "description", "summary", "method", "id", "handlers"];
+  }
+
+  beforeInit() {
+    const path = this.get("path");
+    const method = exports.OperationMethods[this.get("method")] || exports.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 "handlers":
+        if (core.isFunction(this.entity.use)) {
+          this.entity.use(value);
+          return;
+        }
+
+        break;
+    }
+
+    return super.onMapKey(key, value);
+  }
+
+}
+
+function Route(...args) {
+  const routeOptions = mapRouteOptions(args);
+  const context = new RouteDecoratorContext(routeOptions);
+  return context.build();
+}
+/**
+ * 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(...[exports.OperationMethods.ALL, path].concat(args));
+}
+/**
+ * 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(...[exports.OperationMethods.GET, path].concat(args));
+}
+/**
+ * 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(...[exports.OperationMethods.POST, path].concat(args));
+}
+/**
+ * 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(...[exports.OperationMethods.PUT, path].concat(args));
+}
+/**
+ * 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(...[exports.OperationMethods.DELETE, path].concat(args));
+}
+/**
+ * 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(...[exports.OperationMethods.HEAD, path].concat(args));
+}
+/**
+ * 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(...[exports.OperationMethods.PATCH, path].concat(args));
+}
+/**
+ * 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(...[exports.OperationMethods.OPTIONS, path].concat(args));
+}
+
 /**
  * Accept unknown properties on the deserialized model.
  *
@@ -7495,6 +7747,7 @@ function JsonEntityComponent(type) {
 }
 
 exports.AdditionalProperties = AdditionalProperties;
+exports.All = All;
 exports.AllOf = AllOf;
 exports.Allow = Allow;
 exports.Any = Any;
@@ -7510,6 +7763,7 @@ exports.CustomKeys = CustomKeys;
 exports.DateFormat = DateFormat;
 exports.DateTime = DateTime;
 exports.Default = Default;
+exports.Delete = Delete;
 exports.Deprecated = Deprecated;
 exports.Description = Description;
 exports.Email = Email;
@@ -7522,8 +7776,11 @@ exports.Format = Format;
 exports.ForwardGroups = ForwardGroups;
 exports.GenericOf = GenericOf;
 exports.Generics = Generics;
+exports.Get = Get;
 exports.Groups = Groups;
+exports.HTTP_METHODS = HTTP_METHODS;
 exports.HTTP_STATUS_MESSAGES = HTTP_STATUS_MESSAGES;
+exports.Head = Head;
 exports.Header = Header;
 exports.Hidden = Hidden;
 exports.Ignore = Ignore;
@@ -7560,16 +7817,21 @@ exports.OneOf = OneOf;
 exports.OperationId = OperationId;
 exports.OperationPath = OperationPath;
 exports.Optional = Optional;
+exports.Options = Options;
 exports.Partial = Partial;
+exports.Patch = Patch;
 exports.Path = Path;
 exports.Pattern = Pattern;
+exports.Post = Post;
 exports.Produces = Produces;
 exports.Property = Property;
+exports.Put = Put;
 exports.ReadOnly = ReadOnly;
 exports.Redirect = Redirect;
 exports.Required = Required;
 exports.RequiredGroups = RequiredGroups;
 exports.Returns = Returns;
+exports.Route = Route;
 exports.Schema = Schema;
 exports.Security = Security;
 exports.Status = Status;