@tsed/schema 6.72.2 → 6.73.2

package/lib/index.modern.js

@@ -1,5 +1,5 @@
 import { constantCase, pascalCase, camelCase } from 'change-case';
-import { Store, decoratorTypeOf, nameOf, isFunction, cleanObject, isPromise, isClass, isSymbol, isPrimitiveOrPrimitiveClass, isClassObject, isDate, isCollection, classOf, isArrowFn, primitiveOf, isArray, Hooks, uniq, isObject, uniqBy, deepMerge, toMap, Entity, DecoratorTypes, descriptorOf, Metadata, isPrimitiveClass, ancestorsOf, mergeReducerBuilder, UnsupportedDecoratorType, decorateMethodsOf, isString, isPlainObject, isNumber, useDecorators, StoreSet } from '@tsed/core';
+import { Store, decoratorTypeOf, nameOf, isFunction, cleanObject, isPromise, isClass, isSymbol, isPrimitiveOrPrimitiveClass, isClassObject, isDate, isCollection, classOf, isArrowFn, primitiveOf, isArray, Hooks, uniq, isObject, uniqBy, deepMerge, toMap, Entity, DecoratorTypes, descriptorOf, Metadata, isPlainObject, isPrimitiveClass, ancestorsOf, mergeReducerBuilder, UnsupportedDecoratorType, decorateMethodsOf, isString, isNumber, useDecorators, StoreSet } from '@tsed/core';
 import micromatch from 'micromatch';
 
 const HTTP_STATUS_MESSAGES = {
@@ -78,6 +78,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"];
+var OperationMethods;
+
+(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";
+})(OperationMethods || (OperationMethods = {}));
+
 function _extends() {
   _extends = Object.assign || function (target) {
     for (var i = 1; i < arguments.length; i++) {
@@ -2202,7 +2217,11 @@ class JsonEntityStore extends Entity {
       if (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 && isPlainObject(this._type)) {
+          this._type = String;
+        }
       }
     }
 
@@ -4245,9 +4264,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) {
@@ -4256,7 +4278,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) => {
@@ -4299,6 +4321,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);
@@ -4306,6 +4346,10 @@ class DecoratorContext extends Map {
     return this;
   }
 
+  beforeInit() {}
+
+  afterInit() {}
+
 }
 
 /**
@@ -4467,9 +4511,9 @@ class ReturnDecoratorContext extends DecoratorContext {
 
     switch (type) {
       case DecoratorTypes.METHOD:
-        this.store = JsonEntityStore.from(...args);
+        this.entity = JsonEntityStore.from(...args);
 
-        if (this.store.operation) {
+        if (this.entity.operation) {
           this.map();
         }
 
@@ -4490,10 +4534,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();
@@ -4516,7 +4560,7 @@ class ReturnDecoratorContext extends DecoratorContext {
 
     if (isSuccessStatus(this.get("status")) || currentStatus === "default") {
       if (model) {
-        store.type = model;
+        entity.type = model;
       }
     } // additional info for OS2
 
@@ -4687,19 +4731,6 @@ function OperationId(operationId) {
   });
 }
 
-var OperationMethods;
-
-(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";
-})(OperationMethods || (OperationMethods = {}));
 /**
  * Declare new Operation with his path and http method.
  *
@@ -4720,7 +4751,6 @@ var OperationMethods;
  * @operation
  */
 
-
 function OperationPath(method, path = "/") {
   return JsonEntityFn((store, args) => {
     if (store.decoratorType !== DecoratorTypes.METHOD) {
@@ -5228,6 +5258,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 = OperationMethods[this.get("method")] || 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 (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(...[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(...[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(...[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(...[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(...[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(...[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(...[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(...[OperationMethods.OPTIONS, path].concat(args));
+}
+
 /**
  * Accept unknown properties on the deserialized model.
  *
@@ -7491,5 +7743,5 @@ function JsonEntityComponent(type) {
   };
 }
 
-export { AdditionalProperties, AllOf, Allow, Any, AnyOf, ArrayOf, CollectionContains, CollectionOf, Const, Consumes, ContentType, CustomKey, CustomKeys, DateFormat, DateTime, Default, Deprecated, Description, Email, Enum, Example, ExclusiveMaximum, ExclusiveMinimum, For, Format, ForwardGroups, GenericOf, Generics, Groups, HTTP_STATUS_MESSAGES, Header, Hidden, Ignore, In, Integer, JSON_TYPES, JsonEntityComponent, JsonEntityFn, JsonEntityStore, JsonFormatTypes, JsonLazyRef, JsonMap, JsonMedia, JsonOperation, JsonParameter, JsonParameterTypes, JsonRequestBody, JsonResponse, JsonSchema, Location, MapOf, Max, MaxItems, MaxLength, MaxProperties, Maximum, Min, MinItems, MinLength, MinProperties, Minimum, MultipleOf, Name, Nullable, OneOf, OperationId, OperationMethods, OperationPath, Optional, Partial, Path, Pattern, Produces, Property, ReadOnly, Redirect, Required, RequiredGroups, Returns, Schema, Security, SpecTypes, Status, Summary, Tags, TimeFormat, Title, UniqueItems, Uri, Url, WriteOnly, allOf, alterIgnore, any, anyOf, array, boolean, date, datetime, defineStatusModel, email, formatParameterType, from, getGenericsMap, getJsonSchema, getJsonType, getOperationsStores, getProperties, getPropertiesStores, getSpec, getStatusConstant, getStatusMessage, getStatusModel, integer, isParameterType, isRedirectionStatus, isSuccessStatus, lazyRef, map, mapGenericsOptions, mapHeaders, mergeSpec, number, object, oneOf, parameters, popGenerics, schemesReducer, security, set, string, tagsReducer, time, uri, url };
+export { AdditionalProperties, All, AllOf, Allow, Any, AnyOf, ArrayOf, CollectionContains, CollectionOf, Const, Consumes, ContentType, CustomKey, CustomKeys, DateFormat, DateTime, Default, Delete, Deprecated, Description, Email, Enum, Example, ExclusiveMaximum, ExclusiveMinimum, For, Format, ForwardGroups, GenericOf, Generics, Get, Groups, HTTP_METHODS, HTTP_STATUS_MESSAGES, Head, Header, Hidden, Ignore, In, Integer, JSON_TYPES, JsonEntityComponent, JsonEntityFn, JsonEntityStore, JsonFormatTypes, JsonLazyRef, JsonMap, JsonMedia, JsonOperation, JsonParameter, JsonParameterTypes, JsonRequestBody, JsonResponse, JsonSchema, Location, MapOf, Max, MaxItems, MaxLength, MaxProperties, Maximum, Min, MinItems, MinLength, MinProperties, Minimum, MultipleOf, Name, Nullable, OneOf, OperationId, OperationMethods, OperationPath, Optional, Options, Partial, Patch, Path, Pattern, Post, Produces, Property, Put, ReadOnly, Redirect, Required, RequiredGroups, Returns, Route, Schema, Security, SpecTypes, Status, Summary, Tags, TimeFormat, Title, UniqueItems, Uri, Url, WriteOnly, allOf, alterIgnore, any, anyOf, array, boolean, date, datetime, defineStatusModel, email, formatParameterType, from, getGenericsMap, getJsonSchema, getJsonType, getOperationsStores, getProperties, getPropertiesStores, getSpec, getStatusConstant, getStatusMessage, getStatusModel, integer, isParameterType, isRedirectionStatus, isSuccessStatus, lazyRef, map, mapGenericsOptions, mapHeaders, mergeSpec, number, object, oneOf, parameters, popGenerics, schemesReducer, security, set, string, tagsReducer, time, uri, url };
 //# sourceMappingURL=index.modern.js.map