@spinajs/http 2.0.180 → 2.0.181

package/lib/mjs/decorators.js

@@ -1,405 +1,405 @@
-import { RouteType, ParameterType, UuidVersion } from './interfaces.js';
-import { ROUTE_ARG_SCHEMA } from './schemas/RouteArgsSchemas.js';
-export const CONTROLLED_DESCRIPTOR_SYMBOL = Symbol('CONTROLLER_SYMBOL');
-function Controller(callback) {
-    return (target, propertyKey, indexOrDescriptor) => {
-        let metadata = Reflect.getMetadata(CONTROLLED_DESCRIPTOR_SYMBOL, target.prototype || target);
-        if (!metadata) {
-            metadata = {
-                BasePath: null,
-                Middlewares: [],
-                Policies: [],
-                Routes: new Map(),
-            };
-            Reflect.defineMetadata(CONTROLLED_DESCRIPTOR_SYMBOL, metadata, target.prototype || target);
-        }
-        if (callback) {
-            callback(metadata, target, propertyKey, indexOrDescriptor);
-        }
-    };
-}
-export function Route(callback) {
-    return Controller((metadata, target, propertyKey, indexOrDescriptor) => {
-        let route = null;
-        if (propertyKey) {
-            if (metadata.Routes.has(propertyKey)) {
-                route = metadata.Routes.get(propertyKey);
-            }
-            else {
-                route = {
-                    InternalType: RouteType.UNKNOWN,
-                    Method: propertyKey,
-                    Middlewares: [],
-                    Parameters: new Map(),
-                    Path: '',
-                    Policies: [],
-                    Type: RouteType.UNKNOWN,
-                    Options: null,
-                    Schema: null,
-                };
-            }
-            metadata.Routes.set(propertyKey, route);
-        }
-        if (callback) {
-            callback(metadata, route, target, propertyKey, indexOrDescriptor);
-        }
-    });
-}
-/**
- * Ugly hack to specify type for route args. Mostly used to define type of array, becouse typescript does not
- * have information about this.
- */
-export function Type(type) {
-    return Route((_, route, _target, _propertyKey, index) => {
-        if (route.Parameters.has(index)) {
-            route.Parameters.get(index).RuntimeType = type;
-        }
-        else {
-            const param = {
-                Index: index,
-                Name: '',
-                RuntimeType: type,
-                RouteParamSchema: '',
-                Options: null,
-                Type: null,
-            };
-            route.Parameters.set(index, param);
-        }
-    });
-}
-export function Parameter(type, schema, options) {
-    return (_, route, target, propertyKey, index) => {
-        const rType = Reflect.getMetadata('design:paramtypes', target.prototype || target, propertyKey)[index];
-        let tSchema = null;
-        switch (rType.name) {
-            case 'Number':
-                tSchema = ROUTE_ARG_SCHEMA.Number;
-                break;
-            case 'String':
-                tSchema = ROUTE_ARG_SCHEMA.String;
-                break;
-            case 'Boolean':
-                tSchema = ROUTE_ARG_SCHEMA.Boolean;
-        }
-        if (route.Parameters.has(index)) {
-            const p = route.Parameters.get(index);
-            p.Type = type;
-            p.Options = options;
-            p.RouteParamSchema = tSchema;
-            p.Schema = schema;
-        }
-        else {
-            const param = {
-                Index: index,
-                Name: '',
-                RuntimeType: rType,
-                RouteParamSchema: tSchema,
-                Schema: schema,
-                Options: options,
-                Type: type,
-            };
-            route.Parameters.set(index, param);
-        }
-    };
-}
-/**
- * Tells controller how to fill up incoming parameters in controller actions
- *
- * @param hydrator - hydrator class that will fill up incoming argument
- * @param options - additional options passed to hydrator
- */
-export function Hydrator(hydrator, ...options) {
-    return (target) => {
-        if (!Reflect.getMetadata('custom:arg_hydrator', target)) {
-            Reflect.defineMetadata('custom:arg_hydrator', {
-                hydrator,
-                options,
-            }, target);
-        }
-    };
-}
-/**
- *
- * @param policy - policy to set. Could be type or path in configuration to with policy to inject ( eg. metrics.auth.policy )
- * @param options
- * @returns
- */
-export function Policy(policy, ...options) {
-    return Route((controller, route, _, _1, _2) => {
-        const pDesc = {
-            Options: options,
-            Type: policy,
-        };
-        if (route) {
-            route.Policies.push(pDesc);
-        }
-        else {
-            controller.Policies.push(pDesc);
-        }
-    });
-}
-export function Middleware(policy, ...options) {
-    return Route((controller, route, _, _1, _2) => {
-        const pDesc = {
-            Options: options,
-            Type: policy,
-        };
-        if (route) {
-            route.Middlewares.push(pDesc);
-        }
-        else {
-            controller.Middlewares.push(pDesc);
-        }
-    });
-}
-export function BasePath(path) {
-    return Controller((metadata) => {
-        metadata.BasePath = path;
-    });
-}
-export function FromDI() {
-    return Route(Parameter(ParameterType.FromDi));
-}
-/**
- * Gets whole body field
- * @returns body field of request
- */
-export function BodyField() {
-    return Route(Parameter(ParameterType.BodyField));
-}
-export function AcceptType() {
-    return Route(Parameter(ParameterType.RequestType));
-}
-/**
- * Gets all headers field ot type express.IncommingHttpHeaders
- * @returns headers field of request
- */
-export function HeadersField() {
-    return Route(Parameter(ParameterType.Headers));
-}
-/**
- * Get whole query field from request.
- *
- * @returns whole request field of request
- */
-export function QueryField() {
-    return Route(Parameter(ParameterType.QueryField));
-}
-/**
- * Get whole params field from request.
- * @returns whole request field of request
- */
-export function ParamField() {
-    return Route(Parameter(ParameterType.ParamField));
-}
-/**
- * Route parameter taken from query string eg. route?id=1
- *
- * @param schema - parameter json schema for optional validation
- */
-export function Query(schema) {
-    return Route(Parameter(ParameterType.FromQuery, schema));
-}
-/**
- * Route parameter taken from message body (POST)
- *
- * @param schema - parameter json schema for optional validation
- */
-export function Body() {
-    return Route(Parameter(ParameterType.FromBody, null));
-}
-/**
- * Route parameter taken from url parameters eg. route/:id
- *
- * @param schema - parameter json schema for optional validation
- */
-export function Param(schema) {
-    return Route(Parameter(ParameterType.FromParams, schema));
-}
-/**
- * Gets parameter from request header. If not keyname is provided
- * variable name is used as header key name
- *
- * @param keyName - header key name ( optional )
- * @param schema - schema for validation ( optional )
- * @returns
- */
-export function Header(keyName, schema) {
-    return Route(Parameter(ParameterType.FromHeader, schema, { key: keyName }));
-}
-/**
- *
- * Parameter as file
- *
- * @param options - upload options
- */
-export function File(options) {
-    return Route(Parameter(ParameterType.FromFile, null, options));
-}
-/**
- * Data taken from cvs file that is uploaded. Actions receives parsed data
- *
- * @param options - upload options
- * @param cvsParseOptions - cvs parser options
- * @param schema - optional schema for data validation
- */
-export function CsvFile(options, cvsParseOptions) {
-    return Route(Parameter(ParameterType.FromCSV, null, {
-        uploadOptions: options,
-        cvsOptions: cvsParseOptions,
-    }));
-}
-/**
- * Data taken from cvs file that is uploaded. Actions receives parsed data
- *
- * @param options - upload options
- * @param schema - optional schema for data validation
- */
-export function JsonFile(options) {
-    return Route(Parameter(ParameterType.FromJSONFile, null, options));
-}
-/**
- *
- * Parameter taken from form data (multipart-form)
- *
- * @param options - upload options
- */
-export function Form(options) {
-    return Route(Parameter(ParameterType.FromForm, options));
-}
-/**
- *
- * Parameter taken from form data (multipart-form)
- *
- * @param options - upload options
- */
-export function FormField(schema, options) {
-    return Route(Parameter(ParameterType.FormField, schema, options));
-}
-/**
- *
- * Shortcut for parameter as autoincrement primary key ( number greater than 0)
- *
- */
-export function PKey(type) {
-    return Route(Parameter(type ? type : ParameterType.FromParams, { type: 'number', minimum: 0 }));
-}
-/**
- *
- * Shortcut for parameter as uuid primary key ( string with 32 length )
- *
- */
-export function Uuid(type, version) {
-    return Route(Parameter(type ? type : ParameterType.FromParams, { type: 'string', minLength: 36, maxLength: 36, pattern: '^[0-9a-f]{8}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{12}$' }, {
-        version: version ?? UuidVersion.v4,
-    }));
-}
-/**
- *
- *  Express request
- *
- */
-export function Req() {
-    return Route(Parameter(ParameterType.Req, null));
-}
-/**
- *
- *  Express res
- *
- */
-export function Res() {
-    return Route(Parameter(ParameterType.Res, null));
-}
-/**
- *
- * Parameter taken from model
- *
- * @param options - upload options
- */
-export function Model(model) {
-    return Route(Parameter(ParameterType.FromModel, null, { type: model }));
-}
-/**
- *
- * Parameter taken from coockie
- *
- * @param options - upload options
- */
-export function Cookie() {
-    return Route(Parameter(ParameterType.FromCookie, { type: 'string' }));
-}
-/**
- * Creates HEAD http request method
- * @param path - url path to method eg. /foo/bar/:id
- */
-export function Head(path, schema) {
-    return Route((_, route) => {
-        route.Type = RouteType.HEAD;
-        route.InternalType = RouteType.HEAD;
-        route.Path = path;
-        route.Schema = schema;
-    });
-}
-/**
- * Creates PATCH http request method
- * @param path - url path to method eg. /foo/bar/:id
- */
-export function Patch(path, schema) {
-    return Route((_, route) => {
-        route.Type = RouteType.PATCH;
-        route.InternalType = RouteType.PATCH;
-        route.Path = path;
-        route.Schema = schema;
-    });
-}
-/**
- * Creates DELETE http request method
- * @param path - url path to method eg. /foo/bar/:id
- * @param routeName - route name visible in api. If undefined, method name is taken
- */
-export function Del(path, schema) {
-    return Route((_, route) => {
-        route.Type = RouteType.DELETE;
-        route.InternalType = RouteType.DELETE;
-        route.Path = path;
-        route.Schema = schema;
-    });
-}
-/**
- * Creates PUT http request method
- * @param path - url path to method eg. /foo/bar/:id
- */
-export function Put(path, schema) {
-    return Route((_, route) => {
-        route.Type = RouteType.PUT;
-        route.InternalType = RouteType.PUT;
-        route.Path = path;
-        route.Schema = schema;
-    });
-}
-/**
- * Creates GET http request method
- * @param path - url path to method eg. /foo/bar/:id
- */
-export function Get(path, schema) {
-    return Route((_, route) => {
-        route.Type = RouteType.GET;
-        route.InternalType = RouteType.GET;
-        route.Path = path;
-        route.Schema = schema;
-    });
-}
-/**
- * Creates POST http request method
- *
- * @param path - url path to method eg. /foo/bar
- */
-export function Post(path, schema) {
-    return Route((_, route) => {
-        route.Type = RouteType.POST;
-        route.InternalType = RouteType.POST;
-        route.Path = path;
-        route.Schema = schema;
-    });
-}
+import { RouteType, ParameterType, UuidVersion } from './interfaces.js';
+import { ROUTE_ARG_SCHEMA } from './schemas/RouteArgsSchemas.js';
+export const CONTROLLED_DESCRIPTOR_SYMBOL = Symbol('CONTROLLER_SYMBOL');
+function Controller(callback) {
+    return (target, propertyKey, indexOrDescriptor) => {
+        let metadata = Reflect.getMetadata(CONTROLLED_DESCRIPTOR_SYMBOL, target.prototype || target);
+        if (!metadata) {
+            metadata = {
+                BasePath: null,
+                Middlewares: [],
+                Policies: [],
+                Routes: new Map(),
+            };
+            Reflect.defineMetadata(CONTROLLED_DESCRIPTOR_SYMBOL, metadata, target.prototype || target);
+        }
+        if (callback) {
+            callback(metadata, target, propertyKey, indexOrDescriptor);
+        }
+    };
+}
+export function Route(callback) {
+    return Controller((metadata, target, propertyKey, indexOrDescriptor) => {
+        let route = null;
+        if (propertyKey) {
+            if (metadata.Routes.has(propertyKey)) {
+                route = metadata.Routes.get(propertyKey);
+            }
+            else {
+                route = {
+                    InternalType: RouteType.UNKNOWN,
+                    Method: propertyKey,
+                    Middlewares: [],
+                    Parameters: new Map(),
+                    Path: '',
+                    Policies: [],
+                    Type: RouteType.UNKNOWN,
+                    Options: null,
+                    Schema: null,
+                };
+            }
+            metadata.Routes.set(propertyKey, route);
+        }
+        if (callback) {
+            callback(metadata, route, target, propertyKey, indexOrDescriptor);
+        }
+    });
+}
+/**
+ * Ugly hack to specify type for route args. Mostly used to define type of array, becouse typescript does not
+ * have information about this.
+ */
+export function Type(type) {
+    return Route((_, route, _target, _propertyKey, index) => {
+        if (route.Parameters.has(index)) {
+            route.Parameters.get(index).RuntimeType = type;
+        }
+        else {
+            const param = {
+                Index: index,
+                Name: '',
+                RuntimeType: type,
+                RouteParamSchema: '',
+                Options: null,
+                Type: null,
+            };
+            route.Parameters.set(index, param);
+        }
+    });
+}
+export function Parameter(type, schema, options) {
+    return (_, route, target, propertyKey, index) => {
+        const rType = Reflect.getMetadata('design:paramtypes', target.prototype || target, propertyKey)[index];
+        let tSchema = null;
+        switch (rType.name) {
+            case 'Number':
+                tSchema = ROUTE_ARG_SCHEMA.Number;
+                break;
+            case 'String':
+                tSchema = ROUTE_ARG_SCHEMA.String;
+                break;
+            case 'Boolean':
+                tSchema = ROUTE_ARG_SCHEMA.Boolean;
+        }
+        if (route.Parameters.has(index)) {
+            const p = route.Parameters.get(index);
+            p.Type = type;
+            p.Options = options;
+            p.RouteParamSchema = tSchema;
+            p.Schema = schema;
+        }
+        else {
+            const param = {
+                Index: index,
+                Name: '',
+                RuntimeType: rType,
+                RouteParamSchema: tSchema,
+                Schema: schema,
+                Options: options,
+                Type: type,
+            };
+            route.Parameters.set(index, param);
+        }
+    };
+}
+/**
+ * Tells controller how to fill up incoming parameters in controller actions
+ *
+ * @param hydrator - hydrator class that will fill up incoming argument
+ * @param options - additional options passed to hydrator
+ */
+export function Hydrator(hydrator, ...options) {
+    return (target) => {
+        if (!Reflect.getMetadata('custom:arg_hydrator', target)) {
+            Reflect.defineMetadata('custom:arg_hydrator', {
+                hydrator,
+                options,
+            }, target);
+        }
+    };
+}
+/**
+ *
+ * @param policy - policy to set. Could be type or path in configuration to with policy to inject ( eg. metrics.auth.policy )
+ * @param options
+ * @returns
+ */
+export function Policy(policy, ...options) {
+    return Route((controller, route, _, _1, _2) => {
+        const pDesc = {
+            Options: options,
+            Type: policy,
+        };
+        if (route) {
+            route.Policies.push(pDesc);
+        }
+        else {
+            controller.Policies.push(pDesc);
+        }
+    });
+}
+export function Middleware(policy, ...options) {
+    return Route((controller, route, _, _1, _2) => {
+        const pDesc = {
+            Options: options,
+            Type: policy,
+        };
+        if (route) {
+            route.Middlewares.push(pDesc);
+        }
+        else {
+            controller.Middlewares.push(pDesc);
+        }
+    });
+}
+export function BasePath(path) {
+    return Controller((metadata) => {
+        metadata.BasePath = path;
+    });
+}
+export function FromDI() {
+    return Route(Parameter(ParameterType.FromDi));
+}
+/**
+ * Gets whole body field
+ * @returns body field of request
+ */
+export function BodyField() {
+    return Route(Parameter(ParameterType.BodyField));
+}
+export function AcceptType() {
+    return Route(Parameter(ParameterType.RequestType));
+}
+/**
+ * Gets all headers field ot type express.IncommingHttpHeaders
+ * @returns headers field of request
+ */
+export function HeadersField() {
+    return Route(Parameter(ParameterType.Headers));
+}
+/**
+ * Get whole query field from request.
+ *
+ * @returns whole request field of request
+ */
+export function QueryField() {
+    return Route(Parameter(ParameterType.QueryField));
+}
+/**
+ * Get whole params field from request.
+ * @returns whole request field of request
+ */
+export function ParamField() {
+    return Route(Parameter(ParameterType.ParamField));
+}
+/**
+ * Route parameter taken from query string eg. route?id=1
+ *
+ * @param schema - parameter json schema for optional validation
+ */
+export function Query(schema) {
+    return Route(Parameter(ParameterType.FromQuery, schema));
+}
+/**
+ * Route parameter taken from message body (POST)
+ *
+ * @param schema - parameter json schema for optional validation
+ */
+export function Body() {
+    return Route(Parameter(ParameterType.FromBody, null));
+}
+/**
+ * Route parameter taken from url parameters eg. route/:id
+ *
+ * @param schema - parameter json schema for optional validation
+ */
+export function Param(schema) {
+    return Route(Parameter(ParameterType.FromParams, schema));
+}
+/**
+ * Gets parameter from request header. If not keyname is provided
+ * variable name is used as header key name
+ *
+ * @param keyName - header key name ( optional )
+ * @param schema - schema for validation ( optional )
+ * @returns
+ */
+export function Header(keyName, schema) {
+    return Route(Parameter(ParameterType.FromHeader, schema, { key: keyName }));
+}
+/**
+ *
+ * Parameter as file
+ *
+ * @param options - upload options
+ */
+export function File(options) {
+    return Route(Parameter(ParameterType.FromFile, null, options));
+}
+/**
+ * Data taken from cvs file that is uploaded. Actions receives parsed data
+ *
+ * @param options - upload options
+ * @param cvsParseOptions - cvs parser options
+ * @param schema - optional schema for data validation
+ */
+export function CsvFile(options, cvsParseOptions) {
+    return Route(Parameter(ParameterType.FromCSV, null, {
+        uploadOptions: options,
+        cvsOptions: cvsParseOptions,
+    }));
+}
+/**
+ * Data taken from cvs file that is uploaded. Actions receives parsed data
+ *
+ * @param options - upload options
+ * @param schema - optional schema for data validation
+ */
+export function JsonFile(options) {
+    return Route(Parameter(ParameterType.FromJSONFile, null, options));
+}
+/**
+ *
+ * Parameter taken from form data (multipart-form)
+ *
+ * @param options - upload options
+ */
+export function Form(options) {
+    return Route(Parameter(ParameterType.FromForm, options));
+}
+/**
+ *
+ * Parameter taken from form data (multipart-form)
+ *
+ * @param options - upload options
+ */
+export function FormField(schema, options) {
+    return Route(Parameter(ParameterType.FormField, schema, options));
+}
+/**
+ *
+ * Shortcut for parameter as autoincrement primary key ( number greater than 0)
+ *
+ */
+export function PKey(type) {
+    return Route(Parameter(type ? type : ParameterType.FromParams, { type: 'number', minimum: 0 }));
+}
+/**
+ *
+ * Shortcut for parameter as uuid primary key ( string with 32 length )
+ *
+ */
+export function Uuid(type, version) {
+    return Route(Parameter(type ? type : ParameterType.FromParams, { type: 'string', minLength: 36, maxLength: 36, pattern: '^[0-9a-f]{8}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{12}$' }, {
+        version: version ?? UuidVersion.v4,
+    }));
+}
+/**
+ *
+ *  Express request
+ *
+ */
+export function Req() {
+    return Route(Parameter(ParameterType.Req, null));
+}
+/**
+ *
+ *  Express res
+ *
+ */
+export function Res() {
+    return Route(Parameter(ParameterType.Res, null));
+}
+/**
+ *
+ * Parameter taken from model
+ *
+ * @param options - upload options
+ */
+export function Model(model) {
+    return Route(Parameter(ParameterType.FromModel, null, { type: model }));
+}
+/**
+ *
+ * Parameter taken from coockie
+ *
+ * @param options - upload options
+ */
+export function Cookie() {
+    return Route(Parameter(ParameterType.FromCookie, { type: 'string' }));
+}
+/**
+ * Creates HEAD http request method
+ * @param path - url path to method eg. /foo/bar/:id
+ */
+export function Head(path, schema) {
+    return Route((_, route) => {
+        route.Type = RouteType.HEAD;
+        route.InternalType = RouteType.HEAD;
+        route.Path = path;
+        route.Schema = schema;
+    });
+}
+/**
+ * Creates PATCH http request method
+ * @param path - url path to method eg. /foo/bar/:id
+ */
+export function Patch(path, schema) {
+    return Route((_, route) => {
+        route.Type = RouteType.PATCH;
+        route.InternalType = RouteType.PATCH;
+        route.Path = path;
+        route.Schema = schema;
+    });
+}
+/**
+ * Creates DELETE http request method
+ * @param path - url path to method eg. /foo/bar/:id
+ * @param routeName - route name visible in api. If undefined, method name is taken
+ */
+export function Del(path, schema) {
+    return Route((_, route) => {
+        route.Type = RouteType.DELETE;
+        route.InternalType = RouteType.DELETE;
+        route.Path = path;
+        route.Schema = schema;
+    });
+}
+/**
+ * Creates PUT http request method
+ * @param path - url path to method eg. /foo/bar/:id
+ */
+export function Put(path, schema) {
+    return Route((_, route) => {
+        route.Type = RouteType.PUT;
+        route.InternalType = RouteType.PUT;
+        route.Path = path;
+        route.Schema = schema;
+    });
+}
+/**
+ * Creates GET http request method
+ * @param path - url path to method eg. /foo/bar/:id
+ */
+export function Get(path, schema) {
+    return Route((_, route) => {
+        route.Type = RouteType.GET;
+        route.InternalType = RouteType.GET;
+        route.Path = path;
+        route.Schema = schema;
+    });
+}
+/**
+ * Creates POST http request method
+ *
+ * @param path - url path to method eg. /foo/bar
+ */
+export function Post(path, schema) {
+    return Route((_, route) => {
+        route.Type = RouteType.POST;
+        route.InternalType = RouteType.POST;
+        route.Path = path;
+        route.Schema = schema;
+    });
+}
 //# sourceMappingURL=decorators.js.map