bootpress 9.0.2 → 10.0.0

package/.eslintrc

@@ -0,0 +1,15 @@
+{
+    "env": {
+      "browser": false,
+      "node": true,
+      "es6": true
+    },
+    "parserOptions": {
+      "ecmaVersion": 2021
+    },
+    "rules": {
+      "no-unused-vars": ["warn", { "varsIgnorePattern": "^_" }],
+      "no-undef": "error"
+    }
+  }
+  

package/.gitattributes

@@ -0,0 +1,2 @@
+*.d.ts linguist-detectable=true
+*.ts linguist-detectable=true

package/README.md

@@ -1,5 +1,5 @@
 <h1 align="center" style="margin-bottom: 0" >
-<img src="https://raw.githubusercontent.com/ufukbakan/bootpress/main/bootpress.svg" height=120 alt="bootpress">
+<img src="https://raw.githubusercontent.com/ufukbakan/bootpress/main/bootpress.svg" width=500 alt="bootpress">
 </h1>
 <p align=center>Express but Spring Boot like</p>
 
@@ -61,13 +61,17 @@ class PostServiceImpl {
         return new HttpResponse(201, casted.id);
     }
     delete(deleteInQuery: string | undefined, idInQuery: string | undefined) {
-        const idx = deleteInQuery === "yes" ? this.posts.indexOf(as(idInQuery, "integer")) : -1;
-        if (idx > -1) {
-            this.#logDeleted(idInQuery);
-            return this.posts.splice(idx, 1);
-        }else {
-            throw new HttpError(404, "Post is not found")
+        if (deleteInQuery === "yes") {
+            const id = as(idInQuery, "integer");
+            const index = this.posts.indexOf(id);
+            if (index > -1) {
+                this.#logDeleted(idInQuery!);
+                return this.posts.splice(index, 1);
+            } else {
+                throw new HttpError(404, "Post is not found")
+            }
         }
+        throw new HttpError(400, "Bad Request");
     }
     // use private methods to  
     #logDeleted(id: number | string) {
@@ -139,9 +143,9 @@ app.get("/logs", LogService.findAll() as RequestHandler)
 
 ```PassBody(serviceFunction)``` -> Passes body to service function without any validation
 
-```ParseBodyAs(type)(serviceFunction)``` -> Parses body to specified type then passes it to service function
+```ParseBodyAs(type, config?)(serviceFunction)``` -> Parses body to specified type then passes it to service function. Config object is optional and has messageTemplate field which represents a string with details placeholder: ```{0}```
 
-```PassBodyAs(type)(serviceFunction)``` -> Validates body with provided type and passes it to service function
+```PassBodyAs(type, config?)(serviceFunction)``` -> Validates body with provided type and passes it to service function. Config object is optional and has messageTemplate field which represents a string with details placeholder: ```{0}```
 
 ```PassAllParams(serviceFunction)``` -> Passes all path parameters to service function as a Record<string, string> (pure js object that contains key-value pairs)
 
@@ -179,11 +183,11 @@ Returns the value back if it's not null, undefined or empty array.
 Returns the value if it's not null or undefined otherwise returns the default value.
 ### **schema(object)**
 Helps you to define a JS Schema.
-### **as(any, string | object | array)**
-Tries to parse any value to provided type.
-
+### **as(target: any, [type: string | object | array](#type-paramter-for-as--asstrict-methods), [config? object](#config-object-optional-for-as--asstrict-methods))**
+Tries to parse target value to provided type.
+#### Type paramter (for as & asStrict methods)
 If type of provided type is string then it's a primitive key and valid values are:
-```
+```ts
 "string"
 "string[]"
 "boolean"
@@ -202,25 +206,43 @@ If type of provided type is string then it's a primitive key and valid values ar
 "integer[]?"
 ```
 If typeof provided type is object then it's a JS Schema and structure must follow:
-```
+```ts
 {
-    "property": string | object | array // Nullable primitives not allowed here instead use question mark end of the property key
-    "nullableProperty?": string | object | array
+    "property": string | object | Array // Nullable primitives not allowed here instead use question mark end of the property key
+    "nullableProperty?": string | object | Array
 }
 ```
 
 If typeof provided type is an array the structure must follow: 
-```
+```ts
 [
     yourJsSchemaObject
 ]
 ```
 There must be only one element in an array schema which defines ````ArrayOf<Schema>````
-### **asStrict(any, string | object | array)**
+#### Config object (optional for as & asStrict methods)
+Config object is optional and structure follows:
+```ts
+{
+    errorVariableName: string | undefined, // variable name in the error message
+    messageTemplate: string | undefined // default values is "{0}" where it directly writes error details.
+    // an messageTemplate example is: "Parse error:\n{0}"
+}
+```
+### **asStrict(target: any, [type: string | object | array](#type-parameter), [config? object](#config-object-optional-for-as--asstrict-methods))**
 Same as 'as' method but doesn't try to parse different types instead throws error.
 
 # Release Notes
 
+## v10.0.0:
+- Configuration support for as, asStrict, passBodyAs and parseBodyAs methods.
+- Integrated logger. (Changeable via setLogger method)
+- 500 server errors are logged with error level.
+
+## v9.1.0:
+- Fixed chained argument type error bugs
+- Improvements in argument passer type declarations
+
 ## v9.0.2:
 - Added support for null/undefined returning async functions
 

package/helpers/index.d.ts

@@ -21,6 +21,7 @@ type JsSchema = {
 }
 
 type ArraySchema = [JsSchema]
+type TypedArraySchema<A extends ArraySchema> = TypedSchema<A[0]>
 
 type RemoveQuestionMark<T extends string> = T extends `${infer Prefix}?` ? Prefix : T;
 
@@ -34,15 +35,7 @@ export function getOrThrow<T, K extends NonNullable<T>, E extends HttpError>(dat
 export function getOrElse<T, E>(data: T, defaultValue: E): E extends NonNullable<infer T> ? E : T | E;
 export function schema<T extends JsSchema>(schema: T): TypedSchema<T>;
 
-type ExtendedTypeMap = {
-    "string": string,
-    "string[]": string[],
-    "boolean": boolean,
-    "boolean[]": boolean[],
-    "number": number,
-    "number[]": number[],
-    "integer": number,
-    "integer[]": number[],
+interface ExtendedTypeMap extends TypeMap {
     "string?": string | null,
     "string[]?": string[] | null,
     "boolean?": boolean | null,
@@ -54,6 +47,26 @@ type ExtendedTypeMap = {
 }
 
 type ExtendedTypeKeys = keyof ExtendedTypeMap;
-type ExtValOf<T extends ExtendedTypeKeys> = ExtendedTypeMap[T]
-export function as<T extends (ExtendedTypeKeys | JsSchema | ArraySchema)>(o:any, type: T, errorVariableName?: string): T extends ExtendedTypeKeys ? ExtValOf<T> : TypedSchema<T>;
-export function asStrict<T extends (ExtendedTypeKeys | JsSchema | ArraySchema)>(o:any, type: T, errorVariableName?: string): T extends ExtendedTypeKeys ? ExtValOf<T> : TypedSchema<T>;
+type ExtValOf<T extends ExtendedTypeKeys> = ExtendedTypeMap[T];
+type ErrorVariableConfiguration = {
+    errorVariableName?: string
+};
+type ErrorTemplateConfiguration = {
+    messageTemplate?: string
+};
+type ErrorConfiguration = ErrorVariableConfiguration & ErrorTemplateConfiguration;
+
+
+export function as<T extends (ExtendedTypeKeys | JsSchema | ArraySchema)>(o: any, type: T, config?: ErrorConfiguration): T extends ExtendedTypeKeys ? ExtValOf<T> : TypedSchema<T>;
+export function asStrict<T extends (ExtendedTypeKeys | JsSchema | ArraySchema)>(o: any, type: T, config?: ErrorConfiguration): T extends ExtendedTypeKeys ? ExtValOf<T> : TypedSchema<T>;
+
+type Log = {
+    fatal: (message: any) => void,
+    error: (message: any) => void,
+    warn: (message: any) => void,
+    info: (message: any) => void,
+    debug: (message: any) => void,
+    trace: (message: any) => void,
+}
+export const log: Log;
+export function setLogger(logger: Log): void;

package/helpers/index.js

@@ -1,6 +1,41 @@
 const { HttpError } = require("../types");
 
 const allowedPrimitives = ["string", "number", "boolean", "integer"];
+/**
+ * For both getter & setter
+ * 
+ * Any logger with Log4J interface can be usable. (e.g. Pino)
+ * 
+ */
+let _logger = {
+    fatal: (message) => console.error(message),
+    error: (message) => console.error(message),
+    warn: (message) => console.warn(message),
+    info: (message) => console.log(message),
+    debug: (message) => console.log(message),
+    trace: (message) => console.log(message),
+};
+
+const log = {
+    fatal: (message) => _logger.fatal(message),
+    error: (message) => _logger.error(message),
+    warn: (message) => _logger.warn(message),
+    info: (message) => _logger.info(message),
+    debug: (message) => _logger.debug(message),
+    trace: (message) => _logger.trace(message),
+}
+
+function setLogger(logger) {
+    _logger = logger;
+}
+
+function passStringArgs(str, ...args) {
+    let result = str;
+    for (let i = 0; i < args.length; i++) {
+        result = str.replace(`{${i}}`, args[i]);
+    }
+    return result;
+}
 
 function getOrThrow(data, error) {
     if (data === null || data === undefined || isEmptyArray(data)) {
@@ -10,7 +45,7 @@ function getOrThrow(data, error) {
     }
 }
 
-function isEmptyArray(x){
+function isEmptyArray(x) {
     return Array.isArray(x) && x.length < 1;
 }
 
@@ -83,9 +118,12 @@ function asString(o, errorMessage = undefined, errorStatus = 400) {
     }
 }
 
-function asSchema(o, schema, strict = false) {
-    if(!(schema instanceof Object) || Array.isArray(schema)){
-        throw new HttpError(500, `Schema is not valid ${JSON.stringify(schema)}`);
+function asSchema(o, schema, config = { strict: false, messageTemplate: "{0}" }) {
+    const strict = config.strict ?? false;
+    if (!(schema instanceof Object) || Array.isArray(schema)) {
+        const error = new HttpError(500, `Schema is not valid ${JSON.stringify(schema)}`);
+        _logger.error(error.stack);
+        throw error;
     }
     const schemaKeyValues = Object.entries(schema);
     let result = {};
@@ -104,17 +142,19 @@ function asSchema(o, schema, strict = false) {
             if (Array.isArray(expectedType)) {
                 result[key] = [];
                 for (let j = 0; j < o[key].length; j++) {
-                    result[key][j] = asSchema(o[key][j], expectedType[0], strict)
+                    result[key][j] = asSchema(o[key][j], expectedType[0], config)
                 }
             } else {
-                result[key] = asSchema(o[key], expectedType, strict);
+                result[key] = asSchema(o[key], expectedType, config);
             }
         }
         else if (typeof expectedType === "string") {
-            result[key] = strict ? asStrict(o[key], expectedType, key) : as(o[key], expectedType, key);
+            result[key] = strict ? asStrict(o[key], expectedType, { ...config, errorVariableName: key }) : as(o[key], expectedType, { ...config, errorVariableName: key });
         }
         else {
-            throw new HttpError(500, `Type of a schema key should be a primitive type or another schema`);
+            const error = new HttpError(500, `Type of a schema key should be a primitive type or another schema`);
+            _logger.error(error.stack);
+            throw error;
         }
     }
     return result;
@@ -125,117 +165,139 @@ function schema(schema) {
     return schema;
 }
 
-function asPrimitiveArrayOf(o, elementType) {
+function asPrimitiveArrayOf(o, elementType, config = { errorVariableName: o, messageTemplate: "{0}" }) {
+    const messageTemplate = config.messageTemplate ?? "{0}";
     if (Array.isArray(o)) {
         for (let i = 0; i < o.length; i++) {
-            o[i] = checkPrimitive(o[i], elementType, "Array elemet");
+            o[i] = checkPrimitive(o[i], elementType, config);
         }
         return o;
     } else {
-        throw new HttpError(400, `Provided object is not an array: ${JSON.stringify(o)}`)
+        throw new HttpError(400, passStringArgs(messageTemplate, `Provided object is not an array: ${JSON.stringify(o)}`))
     }
 }
 
-function as(o, type, namedErrorVariable = o) {
+function as(o, type, config = { errorVariableName: o, messageTemplate: "{0}" }) {
+    const errorVariableName = config.errorVariableName ?? o;
+    const messageTemplate = config.messageTemplate ?? "{0}";
     if (typeof type === "string") {
         if (type.endsWith("[]")) {
             // array check
             const elementType = type.replace("[]", "");
-            return asPrimitiveArrayOf(o, elementType);
+            return asPrimitiveArrayOf(o, elementType, config);
         } else { // non array types:
             if (type.endsWith("?") && o == null) {
                 return null;
             } else if (type.endsWith("?") && o != null) {
                 const actualType = type.replace("?", "");
-                return as(o, actualType, namedErrorVariable);
+                return as(o, actualType, config);
             }
             // primitive check
             switch (type) {
                 case "string":
-                    return asString(o, `Type of ${namedErrorVariable} should have been a string but it's ${o == null ? "null" : typeof o}`);
+                    return asString(o, passStringArgs(messageTemplate, `Type of ${errorVariableName} should have been a string but it's ${o == null ? "null" : typeof o}`));
                 case "number":
-                    return asNumber(o, `Type of ${namedErrorVariable} should have been a number but it's ${o == null ? "null" : typeof o}`);
+                    return asNumber(o, passStringArgs(messageTemplate, `Type of ${errorVariableName} should have been a number but it's ${o == null ? "null" : typeof o}`));
                 case "boolean":
-                    return asBoolean(o, `Type of ${namedErrorVariable} should have been a boolean but it's ${o == null ? "null" : typeof o}`);
+                    return asBoolean(o, passStringArgs(messageTemplate, `Type of ${errorVariableName} should have been a boolean but it's ${o == null ? "null" : typeof o}`));
                 case "integer":
-                    return asInteger(o, `Type of ${namedErrorVariable} should have been an integer but it's ${o == null ? "null" : typeof o}`);
+                    return asInteger(o, passStringArgs(messageTemplate, `Type of ${errorVariableName} should have been an integer but it's ${o == null ? "null" : typeof o}`));
                 default:
-                    throw new HttpError(500, `Unsupported type ${type}`);
+                    const error = new HttpError(500, `Unsupported type ${type}`);
+                    _logger.error(error.stack);
+                    throw error;
             }
         }
     } else if (typeof type === "object" && type != null) {
         if (Array.isArray(type)) {
             if (type.length > 1) {
-                throw new HttpError(500, `You can define only one schema for types ArrayOf<Schema>`);
+                const error = new HttpError(500, `You can define only one schema for types ArrayOf<Schema>`);
+                _logger.error(error.stack);
+                throw error;
             } else if (type.length < 1) {
-                throw new HttpError(500, `You must define a schema for types ArrayOf<Schema>`);
+                const error = new HttpError(500, `You must define a schema for types ArrayOf<Schema>`);
+                _logger.error(error.stack)
+                throw error;
             }
             // array schema validation
             if (!Array.isArray(o)) {
-                throw new HttpError(400, `Provided value should have been an array. (${JSON.stringify(o)})`)
+                throw new HttpError(400, passStringArgs(messageTemplate, `Provided value should have been an array. (${JSON.stringify(o)})`))
             }
             const providedSchema = type[0];
             let result = [];
             for (let i = 0; i < o.length; i++) {
-                result.push(asSchema(o[i], providedSchema));
+                result.push(asSchema(o[i], providedSchema, config));
             }
             return result;
         } else {
             // schema validation
-            return asSchema(o, type);
+            return asSchema(o, type, config);
         }
     } else {
-        throw new HttpError(500, `Unsupported type check ${type}`)
+        const error = new HttpError(500, `Unsupported type check ${type}`);
+        _logger.error(error);
+        throw error;
     }
 }
 
-function asStrict(o, type, namedErrorVariable = o) {
+function asStrict(o, type, config = { errorVariableName: o, messageTemplate: "{0}" }) {
+    const messageTemplate = config.messageTemplate ?? "{0}";
     if (typeof type === "string") {
         if (type.endsWith("[]")) {
             // array check
             const elementType = type.replace("[]", "");
-            return asPrimitiveArrayOf(o, elementType);
+            return asPrimitiveArrayOf(o, elementType, config);
         } else { // non array types:
             if (type.endsWith("?") && o == null) {
                 return null;
             } else if (type.endsWith("?") && o != null) {
                 const actualType = type.replace("?", "");
-                return asStrict(o, actualType, namedErrorVariable);
+                return asStrict(o, actualType, config);
             }
             // primitive check
             if (!allowedPrimitives.includes(type)) {
-                throw new HttpError(500, `Unsupported type ${type}`);
+                const error = new HttpError(500, `Unsupported type ${type}`);
+                _logger.error(error);
+                throw error;
             }
-            return checkPrimitive(o, type, namedErrorVariable);
+            return checkPrimitive(o, type, config);
         }
     } else if (typeof type === "object" && type != null) {
         if (Array.isArray(type)) {
             if (type.length > 1) {
-                throw new HttpError(500, `You can define only one schema for types ArrayOf<Schema>`);
+                const error = new HttpError(500, `You can define only one schema for types ArrayOf<Schema>`);
+                _logger.error(error);
+                throw error;
             } else if (type.length < 1) {
-                throw new HttpError(500, `You must define a schema for types ArrayOf<Schema>`);
+                const error = new HttpError(500, `You must define a schema for types ArrayOf<Schema>`);
+                _logger.error(error);
+                throw error;
             }
             // array schema validation
             if (!Array.isArray(o)) {
-                throw new HttpError(400, `Provided value should have been an array but it's ${typeof o}`)
+                throw new HttpError(400, passStringArgs(messageTemplate, `Provided value should have been an array but it's ${typeof o}`))
             }
             const providedSchema = type[0];
             let result = [];
             for (let i = 0; i < o.length; i++) {
-                result.push(asSchema(o[i], providedSchema, true));
+                result.push(asSchema(o[i], providedSchema, { ...config, strict: true }));
             }
             return result;
         } else {
             // schema validation
-            return asSchema(o, type, true);
+            return asSchema(o, type, { ...config, strict: true });
         }
     } else {
-        throw new HttpError(500, `Unsupported type check ${type}`)
+        const error = new HttpError(500, `Unsupported type check ${type}`);
+        _logger.error(error);
+        throw error;
     }
 }
 
-function checkPrimitive(o, type, varName = o) {
-    const error = new HttpError(400, `${varName} should have been a ${type}. But it's ${typeof o}`);
+function checkPrimitive(o, type, config = { errorVariableName: o, messageTemplate: "{0}" }) {
+    const errorVariableName = config.errorVariableName ?? o;
+    const messageTemplate = config.messageTemplate ?? "{0}";
+    const error = new HttpError(400, passStringArgs(messageTemplate, `${errorVariableName} should have been a ${type}. But it's ${o == null ? "null" : typeof o}`));
     if (type === "integer") {
         if (!Number.isInteger(o)) {
             throw error;
@@ -253,5 +315,7 @@ module.exports = {
     getOrElse,
     schema,
     as,
-    asStrict
+    asStrict,
+    log,
+    setLogger
 }

package/index.d.ts

@@ -1,13 +1,17 @@
-import { Response, Request } from "express"
-import { ArraySchema, JsSchema, ValidTypeKeys, TypedSchema } from "./helpers"
+import { Request, Response } from "express";
+import { ArraySchema, ErrorTemplateConfiguration, ExtValOf, ExtendedTypeKeys, JsSchema, TypedArraySchema, TypedSchema } from "./helpers";
 
 type RequestHandler = (req: Request, res: Response) => void
-type RequsetHandlerWithArgs = <A extends any[]>(...args: A) => RequestHandler
-type RequsetHandlerWithFirstArg<T> = (arg1: T, ...rest: any[]) => RequestHandler
+type ArrayWithLastElement<L> = [...rest: any[], lastArg: L];
+type RequsetHandlerWithLastArg<T, F extends (...args: any) => RequestHandler = (...args: any[]) => RequestHandler, P extends ArrayWithLastElement<T> = Parameters<F>> = (...args: P) => RequestHandler;
 type NonEmptyArray = readonly [any, ...any[]];
-type ShiftRequestHandler<F extends (arg1: any, ...rest: any[]) => RequestHandler> = F extends (arg1: infer T, ...rest: infer U) => RequestHandler ? U extends NonEmptyArray ? (...rest: U) => RequestHandler : RequestHandler : RequestHandler
+type ShiftRequestHandler<F extends RequsetHandlerWithLastArg<any> | RequestHandler> =
+    F extends (arg1: infer T, ...rest: infer U) => RequestHandler ?
+    U extends NonEmptyArray ? (...rest: U) => RequestHandler : RequestHandler
+    : RequestHandler
 
-type RestedService<T extends Record<PropertyKey, any>> = { [K in keyof T]:
+type RestedService<T extends Record<PropertyKey, any>> = {
+    [K in keyof T]:
     T[K] extends Function
     ? (...args: Parameters<T[K]>) => RequestHandler
     : T[K]
@@ -15,35 +19,31 @@ type RestedService<T extends Record<PropertyKey, any>> = { [K in keyof T]:
 
 type InstanceOrClass<T extends Record<PropertyKey, any>> = T | (new () => T);
 
+type TypeValueOf<S extends ExtendedTypeKeys | JsSchema | TypedSchema<JsSchema> | ArraySchema> =
+    S extends TypedSchema<JsSchema> ? S
+    : S extends ExtendedTypeKeys ? ExtValOf<S>
+    : S extends JsSchema ? TypedSchema<S>
+    : S extends ArraySchema ? TypedArraySchema<S>
+    : never;
+
 declare function RestService<T extends Record<PropertyKey, any>>(service: InstanceOrClass<T>): RestedService<T>;
 declare function RestMethod<T>(callback: () => T): RequestHandler;
 declare function Restify(target: any, key: PropertyKey, desc: PropertyDescriptor): PropertyDescriptor;
 
-declare function PassBody<F extends RequsetHandlerWithFirstArg<any>>(serviceFunction: F): ShiftRequestHandler<F>
-declare function ParseBodyAs<T extends ValidTypeKeys | JsSchema | TypedSchema<any> | ArraySchema, F extends RequsetHandlerWithFirstArg<T>>(type: T): (serviceFunction: F) => ShiftRequestHandler<F>
-declare function PassBodyAs<T extends ValidTypeKeys | JsSchema | TypedSchema<any> | ArraySchema, F extends RequsetHandlerWithFirstArg<T>>(type: T): (serviceFunction: F) => ShiftRequestHandler<F>
-declare function PassAllParams<F extends RequsetHandlerWithFirstArg<string[]>>(serviceFunction: F): ShiftRequestHandler<F>
-declare function PassAllQueries<F extends RequsetHandlerWithFirstArg<string[]>>(serviceFunction: F): ShiftRequestHandler<F>
-declare function PassAllCookies<F extends RequsetHandlerWithFirstArg<string[]>>(serviceFunction: F): ShiftRequestHandler<F>
-declare function PassParam<F extends RequsetHandlerWithFirstArg<string | undefined>>(paramName: string): (serviceFunction: F) => ShiftRequestHandler<F>
-declare function PassQuery<F extends RequsetHandlerWithFirstArg<string | undefined>>(queryName: string): (serviceFunction: F) => ShiftRequestHandler<F>
-declare function PassCookie<F extends RequsetHandlerWithFirstArg<string | undefined>>(cookieName: string): (serviceFunction: F) => ShiftRequestHandler<F>
-declare function PassRequest<F extends RequsetHandlerWithFirstArg<Request>>(serviceFunction: F): ShiftRequestHandler<F>
-declare function PassResponse<F extends RequsetHandlerWithFirstArg<Response>>(serviceFunction: F): ShiftRequestHandler<F>
+declare function PassBody<F extends RequsetHandlerWithLastArg<any>>(serviceFunction: F): ShiftRequestHandler<F>
+declare function ParseBodyAs<S extends ExtendedTypeKeys | JsSchema | TypedSchema<JsSchema> | ArraySchema, T = TypeValueOf<S>>(type: S, config?: ErrorTemplateConfiguration): <F extends RequsetHandlerWithLastArg<T>>(serviceFunction: F) => ShiftRequestHandler<F>
+declare function PassBodyAs<S extends ExtendedTypeKeys | JsSchema | TypedSchema<JsSchema> | ArraySchema, T = TypeValueOf<S>>(type: S, config?: ErrorTemplateConfiguration): <F extends RequsetHandlerWithLastArg<T>>(serviceFunction: F) => ShiftRequestHandler<F>
+declare function PassAllParams<F extends RequsetHandlerWithLastArg<string[]>>(serviceFunction: F): ShiftRequestHandler<F>
+declare function PassAllQueries<F extends RequsetHandlerWithLastArg<string[]>>(serviceFunction: F): ShiftRequestHandler<F>
+declare function PassAllCookies<F extends RequsetHandlerWithLastArg<string[]>>(serviceFunction: F): ShiftRequestHandler<F>
+declare function PassParam(paramName: string): <F extends RequsetHandlerWithLastArg<string | undefined>>(serviceFunction: F) => ShiftRequestHandler<F>
+declare function PassQuery(queryName: string): <F extends RequsetHandlerWithLastArg<string | undefined>>(serviceFunction: F) => ShiftRequestHandler<F>
+declare function PassCookie(cookieName: string): <F extends RequsetHandlerWithLastArg<string | undefined>>(serviceFunction: F) => ShiftRequestHandler<F>
+declare function PassRequest<F extends RequsetHandlerWithLastArg<Request>>(serviceFunction: F): ShiftRequestHandler<F>
+declare function PassResponse<F extends RequsetHandlerWithLastArg<Response>>(serviceFunction: F): ShiftRequestHandler<F>
 
 export {
-    RestService,
-    RestMethod,
-    Restify,
-    PassParam,
-    PassAllParams,
-    PassQuery,
-    PassAllQueries,
-    PassCookie,
-    PassAllCookies,
-    PassBody,
-    PassBodyAs,
-    ParseBodyAs,
-    PassRequest,
-    PassResponse
-}
+    ParseBodyAs, PassAllCookies, PassAllParams, PassAllQueries, PassBody,
+    PassBodyAs, PassCookie, PassParam, PassQuery, PassRequest,
+    PassResponse, RestMethod, RestService, Restify
+};

package/index.js

@@ -1,5 +1,4 @@
-const { as, asStrict } = require("./helpers");
-const { HttpError } = require("./types");
+const { as, asStrict, log } = require("./helpers");
 
 const protectedProperties = [
     "toString",
@@ -48,14 +47,18 @@ function RestService(service) {
                                     reply(res, r.status ?? 200, r.data ?? r);
                                 }
                             }).catch(e => {
-                                reply(res, e.status ?? 500, e.message ?? e);
+                                const status = e.status ?? 500;
+                                status === 500 && log.error(e.stack);
+                                reply(res, status, e.message ?? e);
                             })
                         }
                         else {
                             reply(res, result.status ?? 200, result.data ?? result)
                         }
                     } catch (e) {
-                        reply(res, e.status ?? 500, e.message ?? e);
+                        const status = e.status ?? 500;
+                        status === 500 && log.error(e.stack);
+                        reply(res, status, e.message ?? e);
                     }
                 });
         } else {
@@ -80,13 +83,17 @@ function RestMethod(callback) {
                         reply(res, r.status ?? 200, r.data ?? r);
                     }
                 }).catch(e => {
-                    reply(res, e.status ?? 500, e.message ?? e);
+                    const status = e.status ?? 500;
+                    status === 500 && log.error(e.stack);
+                    reply(res, status, e.message ?? e);
                 })
             } else {
                 reply(res, result.status ?? 200, result.data ?? result);
             }
         } catch (e) {
-            reply(res, e.status ?? 500, e.message ?? e)
+            const status = e.status ?? 500;
+            status === 500 && log.error(e.stack);
+            reply(res, status, e.message ?? e)
         }
     }
 }
@@ -110,13 +117,17 @@ function Restify(target, key, desc) {
                                 reply(res, r.status ?? 200, r.data ?? r);
                             }
                         }).catch(e => {
-                            reply(res, e.status ?? 500, e.message ?? e);
+                            const status = e.status ?? 500;
+                            status === 500 && log.error(e.stack);
+                            reply(res, status, e.message ?? e);
                         })
                     } else {
                         reply(res, result.status ?? 200, result.data ?? result);
                     }
                 } catch (e) {
-                    reply(res, e.status ?? 500, e.message ?? e);
+                    const status = e.status ?? 500;
+                    status === 500 && log.error(e.stack);
+                    reply(res, status, e.message ?? e);
                 }
             }
         }).bind(target)
@@ -132,7 +143,7 @@ function isRequest(o) {
 }
 
 function isRequstHandlerArgs(args) {
-    const [last1, last2, last3, ...others] = [...args].reverse();
+    const [_last1, last2, last3, ..._others] = [...args].reverse();
     return isResponse(last2) && isRequest(last3);
 }
 
@@ -186,23 +197,27 @@ function PassAllQueries(actualHandler) {
     }
 }
 
-function ParseBodyAs(type) {
+function ParseBodyAs(type, config = { messageTemplate: "Malformed Request Body\n{0}" }) {
     return (actualHandler) => {
         return (...args) => {
             if (isRequstHandlerArgs(args)) {
                 const req = args.at(-3); const res = args.at(-2);
                 try {
-                    return actualHandler(as(req.body, type))(req, res);
+                    return actualHandler(as(req.body, type, config))(req, res);
                 } catch (e) {
-                    reply(res, e.status || 500, e.message || e);
+                    const status = e.status ?? 500;
+                    status === 500 && log.error(e.stack);
+                    reply(res, status, e.message || e);
                 }
 
             } else {
                 return (req, res) => {
                     try {
-                        return actualHandler(...args, as(req.body, type))(req, res);
+                        return actualHandler(...args, as(req.body, type, config))(req, res);
                     } catch (e) {
-                        reply(res, e.status || 500, e.message || e)
+                        const status = e.status ?? 500;
+                        status === 500 && log.error(e.stack);
+                        reply(res, status, e.message || e)
                     }
                 }
             }
@@ -210,23 +225,27 @@ function ParseBodyAs(type) {
     }
 }
 
-function PassBodyAs(type) {
+function PassBodyAs(type, config = { messageTemplate: "Malformed Request Body\n{0}" }) {
     return (actualHandler) => {
         return (...args) => {
             if (isRequstHandlerArgs(args)) {
                 const req = args.at(-3); const res = args.at(-2);
                 try {
-                    return actualHandler(asStrict(req.body, type))(req, res);
+                    return actualHandler(asStrict(req.body, type, config))(req, res);
                 } catch (e) {
-                    reply(res, e.status || 500, e.message || e);
+                    const status = e.status ?? 500;
+                    status === 500 && log.error(e.stack);
+                    reply(res, status, e.message || e);
                 }
 
             } else {
                 return (req, res) => {
                     try {
-                        return actualHandler(...args, asStrict(req.body, type))(req, res);
+                        return actualHandler(...args, asStrict(req.body, type, config))(req, res);
                     } catch (e) {
-                        reply(res, e.status || 500, e.message || e)
+                        const status = e.status ?? 500;
+                        status === 500 && log.error(e.stack);
+                        reply(res, status, e.message || e)
                     }
                 }
             }
@@ -241,7 +260,9 @@ function PassBody(actualHandler) {
             try {
                 return actualHandler(req.body)(req, res);
             } catch (e) {
-                reply(res, e.status || 500, e.message || e);
+                const status = e.status ?? 500;
+                status === 500 && log.error(e.stack);
+                reply(res, status, e.message || e);
             }
 
         } else {
@@ -249,7 +270,9 @@ function PassBody(actualHandler) {
                 try {
                     return actualHandler(...args, req.body)(req, res);
                 } catch (e) {
-                    reply(res, e.status || 500, e.message || e)
+                    const status = e.status ?? 500;
+                    status === 500 && log.error(e.stack);
+                    reply(res, status, e.message || e)
                 }
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bootpress",
-  "version": "9.0.2",
+  "version": "10.0.0",
   "description": "REST service methods for express",
   "main": "index.js",
   "repository": {
@@ -28,6 +28,7 @@
   },
   "devDependencies": {
     "@types/express": "^4.17.17",
+    "eslint": "^8.55.0",
     "typescript": "^4.9.5"
   }
 }