@tsed/schema 6.72.3 → 6.73.3

package/lib/constants/httpMethods.d.ts

@@ -0,0 +1,12 @@
+export declare const HTTP_METHODS: string[];
+export declare enum OperationMethods {
+    ALL = "ALL",
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT",
+    PATCH = "PATCH",
+    HEAD = "HEAD",
+    DELETE = "DELETE",
+    OPTIONS = "OPTIONS",
+    CUSTOM = "CUSTOM"
+}

package/lib/decorators/index.d.ts

@@ -24,6 +24,7 @@ export * from "./operations/summary";
 export * from "./operations/partial";
 export * from "./operations/redirect";
 export * from "./operations/location";
+export * from "./operations/route";
 export * from "./common/additionalProperties";
 export * from "./common/allow";
 export * from "./common/any";

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

@@ -1,14 +1,4 @@
-export declare enum OperationMethods {
-    ALL = "ALL",
-    GET = "GET",
-    POST = "POST",
-    PUT = "PUT",
-    PATCH = "PATCH",
-    HEAD = "HEAD",
-    DELETE = "DELETE",
-    OPTIONS = "OPTIONS",
-    CUSTOM = "CUSTOM"
-}
+import { OperationMethods } from "../../constants/httpMethods";
 /**
  * Declare new Operation with his path and http method.
  *

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

@@ -0,0 +1,185 @@
+import { OperationMethods } from "../../constants/httpMethods";
+export interface RouteChainedDecorators {
+    <T>(target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<T>): TypedPropertyDescriptor<T> | void;
+    /**
+     * @param string
+     * @constructor
+     */
+    Path(string: string): this;
+    /**
+     * Set the operation method
+     * @param method
+     */
+    Method(method: OperationMethods | string): this;
+    /**
+     * Set the operation id
+     * @param id
+     */
+    Id(id: string): this;
+    /**
+     * Set the operation id
+     * @param name
+     */
+    Name(name: string): this;
+    /**
+     *
+     * @param description
+     */
+    Description(description: string): this;
+    /**
+     * Summary
+     * @constructor
+     * @param Summary
+     */
+    Summary(Summary: string): this;
+}
+/**
+ * Describe a new route with a method and path.
+ *
+ * ```typescript
+ * @Controller('/')
+ * export class Ctrl {
+ *
+ *    @Route('GET', '/')
+ *    get() { }
+ * }
+ *
+ * ```
+ *
+ * @returns {Function}
+ * @param method
+ * @param path
+ * @param args
+ * @decorator
+ * @operation
+ */
+export declare function Route(method: string, path: string, ...args: any[]): RouteChainedDecorators;
+export declare function Route(...args: any[]): RouteChainedDecorators;
+/**
+ * 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
+ */
+export declare function All(path?: string | RegExp | any, ...args: any[]): RouteChainedDecorators;
+/**
+ * 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
+ */
+export declare function Get(path?: string | RegExp | any, ...args: any[]): RouteChainedDecorators;
+/**
+ * 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
+ */
+export declare function Post(path?: string | RegExp | any, ...args: any[]): RouteChainedDecorators;
+/**
+ * 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
+ */
+export declare function Put(path?: string | RegExp | any, ...args: any[]): RouteChainedDecorators;
+/**
+ * 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
+ */
+export declare function Delete(path?: string | RegExp | any, ...args: any[]): RouteChainedDecorators;
+/**
+ * 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
+ */
+export declare function Head(path?: string | RegExp | any, ...args: any[]): RouteChainedDecorators;
+/**
+ * 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
+ */
+export declare function Patch(path?: string | RegExp | any, ...args: any[]): RouteChainedDecorators;
+/**
+ * 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
+ */
+export declare function Options(path?: string | RegExp | any, ...args: any[]): RouteChainedDecorators;

package/lib/domain/DecoratorContext.d.ts

@@ -12,12 +12,17 @@ export interface DecoratorActionHandler {
 export declare abstract class DecoratorContext<T = any> extends Map<string, any> {
     readonly methods: string[];
     protected decoratorType: DecoratorTypes;
-    protected store: JsonEntityStore;
+    protected entity: JsonEntityStore;
     protected actions: DecoratorActionHandler[];
+    constructor(opts?: any);
     addAction(cb: DecoratorActionHandler): this;
     build(): T;
     toObject(): any;
     getMergedKey(key: string, defaultValue: any): any;
-    protected abstract onInit(args: DecoratorParameters, decorator: any): void;
+    protected bind(args: DecoratorParameters, decorator: any): void;
+    protected onInit(args: DecoratorParameters, decorator: any): void;
+    protected onMapKey(key: string, value: any): void;
     protected runActions(): this;
+    protected beforeInit(): void;
+    protected afterInit(): void;
 }

package/lib/domain/JsonEntityStore.d.ts

@@ -16,28 +16,28 @@ export declare class JsonEntityStore extends Entity implements JsonEntityStoreOp
      * Path used to generate open spec.
      */
     path: string;
+    constructor(options: JsonEntityStoreOptions);
     /**
      * Ref to JsonSchema
      */
     protected _schema: JsonSchema;
     /**
-     * Ref to JsonOperation when the decorated object is a method.
-     */
-    protected _operation: JsonOperation;
-    /**
-     * Ref to JsonParameter when the decorated object is a parameter.
+     * Return the JsonSchema
      */
-    protected _parameter: JsonParameter;
+    get schema(): JsonSchema;
     [key: string]: any;
-    constructor(options: JsonEntityStoreOptions);
     /**
-     * Return the JsonSchema
+     * Ref to JsonOperation when the decorated object is a method.
      */
-    get schema(): JsonSchema;
+    protected _operation: JsonOperation;
     /**
      * Return the JsonOperation
      */
     get operation(): JsonOperation | undefined;
+    /**
+     * Ref to JsonParameter when the decorated object is a parameter.
+     */
+    protected _parameter: JsonParameter;
     /**
      * Return the JsonParameter
      */
@@ -79,7 +79,7 @@ export declare class JsonEntityStore extends Entity implements JsonEntityStoreOp
      */
     static from<T extends JsonEntityStore = JsonEntityStore>(...args: any[]): NonNullable<T>;
     static fromMethod(target: any, propertyKey: string | symbol): JsonEntityStore;
-    getResponseOptions(contentType?: string): undefined | any;
+    getResponseOptions(status: number, contentType?: string): undefined | any;
     /**
      * Check precondition between value, required and allowedRequiredValues to know if the entity is required.
      * @param value

package/lib/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./constants/httpStatusMessages";
+export * from "./constants/httpMethods";
 export * from "./utils/getJsonSchema";
 export * from "./utils/getJsonType";
 export * from "./utils/getPropertiesStores";