@tsed/schema 6.70.0 → 6.71.1

package/lib/constants/httpStatusMessages.d.ts

@@ -2,3 +2,4 @@ export declare const HTTP_STATUS_MESSAGES: {
     [key: string]: string;
 };
 export declare function getStatusConstant(status: number): string;
+export declare function getStatusMessage(status: number): string;

package/lib/decorators/index.d.ts

@@ -22,6 +22,8 @@ export * from "./operations/security";
 export * from "./operations/tags";
 export * from "./operations/summary";
 export * from "./operations/partial";
+export * from "./operations/redirect";
+export * from "./operations/location";
 export * from "./common/additionalProperties";
 export * from "./common/allow";
 export * from "./common/any";

package/lib/decorators/operations/location.d.ts

@@ -0,0 +1,22 @@
+import { JsonHeader } from "../../interfaces/JsonOpenSpec";
+/**
+ * Sets the response Location HTTP header to the specified path parameter.
+ *
+ * ```typescript
+ *  @Location('/foo/bar', {description: 'Location to the next step'})
+ *  @Location('http://example.com')
+ *  @Location('back')
+ *  private myMethod() {
+ *
+ *  }
+ * ```
+ *
+ * A path value of “back” has a special meaning, it refers to the URL specified in the `Referer` header of the request. If the `Referer` header was not specified, it refers to “/”.
+ *
+ * @param location
+ * @param meta
+ * @returns {Function}
+ * @decorator
+ * @operation
+ */
+export declare function Location(location: string, meta?: JsonHeader): import("./returns").ReturnsChainedDecorators;

package/lib/decorators/operations/redirect.d.ts

@@ -0,0 +1,52 @@
+import { JsonHeader } from "../../interfaces/JsonOpenSpec";
+/**
+ * Redirects to the URL derived from the specified path, with specified status, a positive integer that corresponds to an HTTP status code . If not specified, status defaults to “302 “Found”.
+ *
+ * ```typescript
+ *  @Redirect('/foo/bar')
+ *  @Redirect(301, 'http://example.com').Type(Model)
+ *  private myMethod() {}
+ * ```
+ * Redirects can be a fully-qualified URL for redirecting to a different site:
+ *
+ * ```typescript
+ *  @Redirect('http://google.com');
+ *  private myMethod() {}
+ * ```
+ *
+ * Redirects can be relative to the root of the host name. For example, if the application is on http://example.com/admin/post/new, the following would redirect to the URL http://example.com/admin:
+ *
+ * ```typescript
+ *  @Redirect('/admin');
+ * ```
+ * Redirects can be relative to the current URL. For example, from http://example.com/blog/admin/ (notice the trailing slash), the following would redirect to the URL http://example.com/blog/admin/post/new.
+ *
+ * ```typescript
+ *  @Redirect('post/new');
+ * ```
+ *
+ * Redirecting to post/new from http://example.com/blog/admin (no trailing slash), will redirect to http://example.com/blog/post/new.
+ *
+ * If you found the above behavior confusing, think of path segments as directories (with trailing slashes) and files, it will start to make sense.
+ *
+ * Path-relative redirects are also possible. If you were on http://example.com/admin/post/new, the following would redirect to http//example.com/admin/post:
+ *
+ * ```typescript
+ *  @Redirect('..');
+ * ``
+ *
+ * A back redirection redirects the request back to the referer, defaulting to / when the referer is missing.
+ *
+ * ```typescript
+ *  @Redirect('back');
+ * ```
+ *
+ * @param url
+ * @param meta
+ * @decorator
+ * @operation
+ * @response
+ * @headers
+ */
+export declare function Redirect(url: string, meta?: JsonHeader): Function;
+export declare function Redirect(status: number, url: string, meta?: JsonHeader): Function;

package/lib/decorators/operations/returns.d.ts

@@ -51,12 +51,16 @@ export interface ReturnsChainedDecorators {
      * @param value
      */
     Header(key: string, value: number | string | (JsonHeader & {
-        value?: string | number;
+        value?: string | number | boolean;
     })): this;
     /**
      * Add headers
      */
     Headers(headers: JsonHeaders): this;
+    /**
+     * Add location hea
+     */
+    Location(location: string, meta?: JsonHeader): this;
     /**
      * Assign partial schema
      * @param schema

package/lib/domain/JsonOperation.d.ts

@@ -14,8 +14,8 @@ export interface JsonOperationOptions extends OS3Operation<JsonSchema, JsonParam
     produces: string[];
 }
 export declare class JsonOperation extends JsonMap<JsonOperationOptions> {
+    #private;
     readonly operationPaths: Map<string, JsonMethodPath>;
-    private _status;
     constructor(obj?: Partial<JsonOperationOptions>);
     get response(): JsonResponse | undefined;
     get status(): number;
@@ -24,15 +24,17 @@ export declare class JsonOperation extends JsonMap<JsonOperationOptions> {
     summary(summary: string): this;
     operationId(operationId: string): this;
     responses(responses: JsonMap<any>): this;
-    defaultStatus(status: number): void;
+    defaultStatus(status: number): this;
     getStatus(): number;
+    setRedirection(status?: number): this;
+    isRedirection(status?: number): boolean | 0;
     addResponse(statusCode: string | number, response: JsonResponse): this;
     getResponses(): JsonMap<JsonResponse>;
     getResponseOf(status: number | string): JsonResponse;
     ensureResponseOf(status: number | string): JsonResponse;
-    getHeadersOf(status: number): {
-        [key: string]: JsonHeader;
-    };
+    getHeadersOf(status: number): Record<string, JsonHeader & {
+        example: string;
+    }>;
     getContentTypeOf(status: number): any;
     security(security: OpenSpecSecurity): this;
     addSecurityScopes(name: string, scopes: string[]): this;

package/lib/index.js

@@ -78,6 +78,9 @@ const HTTP_STATUS_MESSAGES = {
 function getStatusConstant(status) {
   return changeCase.constantCase(HTTP_STATUS_MESSAGES[status]);
 }
+function getStatusMessage(status) {
+  return HTTP_STATUS_MESSAGES[status];
+}
 
 function _extends() {
   _extends = Object.assign || function (target) {
@@ -112,6 +115,20 @@ function _objectWithoutPropertiesLoose(source, excluded) {
   return target;
 }
 
+var id = 0;
+
+function _classPrivateFieldLooseKey(name) {
+  return "__private_" + id++ + "_" + name;
+}
+
+function _classPrivateFieldLooseBase(receiver, privateKey) {
+  if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) {
+    throw new TypeError("attempted to use private field on non-instance");
+  }
+
+  return receiver;
+}
+
 /**
  * @ignore
  */
@@ -331,6 +348,7 @@ function anyMapper(input, options = {}) {
 registerJsonSchemaMapper("any", anyMapper);
 
 const isSuccessStatus = code => Number(code) && 200 <= Number(code) && Number(code) < 300;
+const isRedirectionStatus = code => Number(code) && 300 <= Number(code) && Number(code) < 400;
 
 class JsonMap extends Map {
   constructor(obj = {}) {
@@ -1475,13 +1493,27 @@ class JsonSchema extends Map {
 }
 
 const _excluded$6 = ["schema", "in"];
+
+var _status = /*#__PURE__*/_classPrivateFieldLooseKey("status");
+
+var _redirection = /*#__PURE__*/_classPrivateFieldLooseKey("redirection");
+
 class JsonOperation extends JsonMap {
   constructor(obj = {}) {
     super(_extends({
       parameters: [],
       responses: new JsonMap()
     }, obj));
+    Object.defineProperty(this, _status, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _redirection, {
+      writable: true,
+      value: void 0
+    });
     this.operationPaths = new Map();
+    _classPrivateFieldLooseBase(this, _redirection)[_redirection] = false;
   }
 
   get response() {
@@ -1489,7 +1521,7 @@ class JsonOperation extends JsonMap {
   }
 
   get status() {
-    return this._status;
+    return _classPrivateFieldLooseBase(this, _status)[_status];
   }
 
   tags(tags) {
@@ -1518,15 +1550,32 @@ class JsonOperation extends JsonMap {
   }
 
   defaultStatus(status) {
-    this._status = status;
+    _classPrivateFieldLooseBase(this, _status)[_status] = status;
+    return this;
   }
 
   getStatus() {
-    return this._status || 200;
+    return _classPrivateFieldLooseBase(this, _status)[_status] || 200;
+  }
+
+  setRedirection(status = 302) {
+    _classPrivateFieldLooseBase(this, _redirection)[_redirection] = true;
+    _classPrivateFieldLooseBase(this, _status)[_status] = status;
+    return this;
+  }
+
+  isRedirection(status) {
+    if (_classPrivateFieldLooseBase(this, _redirection)[_redirection]) {
+      if (status) {
+        return isRedirectionStatus(status);
+      }
+    }
+
+    return _classPrivateFieldLooseBase(this, _redirection)[_redirection];
   }
 
   addResponse(statusCode, response) {
-    if (isSuccessStatus(statusCode) && !this._status) {
+    if ((isSuccessStatus(statusCode) || isRedirectionStatus(statusCode)) && !_classPrivateFieldLooseBase(this, _status)[_status]) {
       const res = this.getResponseOf(200);
       this.getResponses().set(statusCode.toString(), res).delete("200");
       this.defaultStatus(Number(statusCode));
@@ -4290,17 +4339,9 @@ class ReturnDecoratorContext extends DecoratorContext {
     model
   }) {
     super();
-    this.methods = ["contentType", "description", "examples", "type", "status", "of", "nested", "header", "headers", "schema", "title", "groups"];
-    this.set("status", status);
-    this.set("model", model);
-
-    if (status && HTTP_STATUS_MESSAGES[status]) {
-      this.set("description", HTTP_STATUS_MESSAGES[status]);
-
-      if (!model) {
-        this.model(getStatusModel(+status));
-      }
-    }
+    this.methods = ["contentType", "description", "examples", "type", "status", "of", "nested", "header", "headers", "schema", "title", "groups", "location"];
+    this.model(model);
+    this.status(status);
   }
 
   type(model) {
@@ -4308,12 +4349,21 @@ class ReturnDecoratorContext extends DecoratorContext {
   }
 
   model(model) {
-    this.set("model", model);
+    model && this.set("model", model);
     return this;
   }
 
   status(status) {
     this.set("status", status);
+
+    if (status && HTTP_STATUS_MESSAGES[status] && !this.get("description")) {
+      this.set("description", HTTP_STATUS_MESSAGES[status]);
+
+      if (!this.get("model")) {
+        this.model(getStatusModel(+status));
+      }
+    }
+
     return this;
   }
 
@@ -4328,6 +4378,15 @@ class ReturnDecoratorContext extends DecoratorContext {
     });
   }
 
+  location(path, meta = {}) {
+    this.headers({
+      Location: _extends({}, meta, {
+        value: path
+      })
+    });
+    return this;
+  }
+
   groups(...groups) {
     this.set("groups", groups);
     return this;
@@ -4427,6 +4486,8 @@ class ReturnDecoratorContext extends DecoratorContext {
       default:
         throw new core.UnsupportedDecoratorType(Returns, args);
     }
+
+    this.clear();
   }
 
   map() {
@@ -5115,6 +5176,61 @@ function Partial() {
   return Groups("partial");
 }
 
+function Redirect(...args) {
+  const {
+    status,
+    url,
+    meta
+  } = args.reduce((options, value) => {
+    if (core.isNumber(value)) {
+      options.status = value;
+      return options;
+    }
+
+    if (core.isString(value)) {
+      options.url = value;
+      return options;
+    }
+
+    options.meta = value;
+    return options;
+  }, {
+    status: 302,
+    url: "",
+    meta: {}
+  });
+  return core.useDecorators(Returns(status).Location(url, meta), JsonEntityFn(entity => {
+    var _entity$operation;
+
+    (_entity$operation = entity.operation) == null ? void 0 : _entity$operation.setRedirection(status);
+  }));
+}
+
+/**
+ * Sets the response Location HTTP header to the specified path parameter.
+ *
+ * ```typescript
+ *  @Location('/foo/bar', {description: 'Location to the next step'})
+ *  @Location('http://example.com')
+ *  @Location('back')
+ *  private myMethod() {
+ *
+ *  }
+ * ```
+ *
+ * A path value of “back” has a special meaning, it refers to the URL specified in the `Referer` header of the request. If the `Referer` header was not specified, it refers to “/”.
+ *
+ * @param location
+ * @param meta
+ * @returns {Function}
+ * @decorator
+ * @operation
+ */
+
+function Location(location, meta) {
+  return Returns().Location(location, meta);
+}
+
 /**
  * Accept unknown properties on the deserialized model.
  *
@@ -7425,6 +7541,7 @@ exports.JsonParameter = JsonParameter;
 exports.JsonRequestBody = JsonRequestBody;
 exports.JsonResponse = JsonResponse;
 exports.JsonSchema = JsonSchema;
+exports.Location = Location;
 exports.MapOf = MapOf;
 exports.Max = Max;
 exports.MaxItems = MaxItems;
@@ -7449,6 +7566,7 @@ exports.Pattern = Pattern;
 exports.Produces = Produces;
 exports.Property = Property;
 exports.ReadOnly = ReadOnly;
+exports.Redirect = Redirect;
 exports.Required = Required;
 exports.RequiredGroups = RequiredGroups;
 exports.Returns = Returns;
@@ -7483,9 +7601,11 @@ exports.getProperties = getProperties;
 exports.getPropertiesStores = getPropertiesStores;
 exports.getSpec = getSpec;
 exports.getStatusConstant = getStatusConstant;
+exports.getStatusMessage = getStatusMessage;
 exports.getStatusModel = getStatusModel;
 exports.integer = integer;
 exports.isParameterType = isParameterType;
+exports.isRedirectionStatus = isRedirectionStatus;
 exports.isSuccessStatus = isSuccessStatus;
 exports.lazyRef = lazyRef;
 exports.map = map;