bootpress 10.0.4 → 11.0.0-rc.2

package/index.d.ts

@@ -1,14 +1,14 @@
-import { Request, Response } from "express";
-import { ArraySchema, ErrorTemplateConfiguration, ExtValOf, ExtendedTypeKeys, JsSchema, TypedArraySchema, TypedSchema } from "./helpers";
-
-type RequestHandler = (req: Request, res: Response) => void
-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 RequsetHandlerWithLastArg<any> | RequestHandler> =
-    F extends (arg1: infer T, ...rest: infer U) => RequestHandler ?
-    U extends NonEmptyArray ? (...rest: U) => RequestHandler : RequestHandler
-    : RequestHandler
+import { Request, Response, NextFunction } from "express";
+import { ArraySchema, ErrorTemplateConfiguration, ExtendedTypeKeys, JsSchema, TypedSchema } from "./helpers";
+
+type RequestHandler = {
+    (req: Request, res: Response): void
+    (req: Request, res: Response, next: NextFunction): void
+}
+
+type FunctionWithArgs<T = any> = (...args: any[]) => T;
+type FunctionWithoutArgs<T = any> = () => T;
+
 
 type RestedService<T extends Record<PropertyKey, any>> = {
     [K in keyof T]:
@@ -19,31 +19,35 @@ type RestedService<T extends Record<PropertyKey, any>> = {
 
 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 extends Function>(callback: T): (args: Parameters<T>) => RequestHandler;
+declare function RestMethod<T extends FunctionWithoutArgs>(callback: T): RequestHandler;
+declare function RestMethod<T extends FunctionWithArgs>(callback: T): (...args: Parameters<T>) => RequestHandler;
 declare function Restify(target: any, key: PropertyKey, desc: PropertyDescriptor): PropertyDescriptor;
 
-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>
+type BodyArgGetter = {
+    (type: ExtendedTypeKeys | JsSchema | TypedSchema<JsSchema> | ArraySchema): NeedsBuilder;
+    (type: ExtendedTypeKeys | JsSchema | TypedSchema<JsSchema> | ArraySchema, config: ErrorTemplateConfiguration): NeedsBuilder;
+}
+
+type NeedsBuilder = {
+    param: (name: string) => NeedsBuilder;
+    params: () => NeedsBuilder;
+    query: (name: string) => NeedsBuilder;
+    queries: () => NeedsBuilder;
+    body: (() => NeedsBuilder) | BodyArgGetter;
+    parseBody: BodyArgGetter;
+    cookie: (name: string) => NeedsBuilder;
+    cookies: () => NeedsBuilder;
+    header: (name: string) => NeedsBuilder;
+    headers: () => NeedsBuilder;
+    to: (handler: FunctionWithArgs) => RequestHandler;
+}
+declare function Needs(): NeedsBuilder;
 
 export {
-    ParseBodyAs, PassAllCookies, PassAllParams, PassAllQueries, PassBody,
-    PassBodyAs, PassCookie, PassParam, PassQuery, PassRequest,
-    PassResponse, RestMethod, RestService, Restify
+    RestMethod,
+    RestService,
+    Restify,
+    Needs
 };
+

package/index.js

@@ -1,5 +1,4 @@
 const { as, asStrict, log } = require("./helpers");
-const { HttpError } = require("./types");
 
 const protectedProperties = [
     "toString",
@@ -36,7 +35,7 @@ function RestService(service) {
             const value = keyvalue[1].value;
             if (typeof value == "function" && !propertyName.startsWith("#")) {
                 newService[propertyName] = ((...args) =>
-                    (req, res) => {
+                    (_req, res) => {
                         try {
                             const result = service[propertyName](...args);
                             if (result == undefined) {
@@ -72,34 +71,35 @@ function RestService(service) {
 }
 
 function RestMethod(callback) {
-    if (callback.length < 1) {
-        return handle(callback());
-    }
-    return (...args) => handle(callback(...args));
+    return callback.length == 0
+        ? handle(callback())
+        : (...args) => handle(callback(...args));
     function handle(result) {
-        try {
-            if (result == undefined) {
-                reply(res, 204, null);
-            } else if (result instanceof Promise) {
-                result.then((r) => {
-                    if (r == undefined) {
-                        reply(res, 204, undefined);
-                    } else {
-                        reply(res, r.status ?? 200, r.data ?? r);
-                    }
-                })
-                    .catch((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);
+        return (_req, res) => {
+            try {
+                if (result == undefined) {
+                    reply(res, 204, null);
+                } else if (result instanceof Promise) {
+                    result.then((r) => {
+                        if (r == undefined) {
+                            reply(res, 204, undefined);
+                        } else {
+                            reply(res, r.status ?? 200, r.data ?? r);
+                        }
+                    })
+                        .catch((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) {
+                const status = e.status ?? 500;
+                status === 500 && log.error(e.stack);
+                reply(res, status, e.message ?? e);
             }
-        } catch (e) {
-            const status = e.status ?? 500;
-            status === 500 && log.error(e.stack);
-            reply(res, status, e.message ?? e);
         }
     }
 }
@@ -140,230 +140,76 @@ function Restify(target, key, desc) {
     }
 }
 
-
-function isResponse(o) {
-    return o instanceof Object && "socket" in o && "parser" in o.socket && "_httpMessage" in o.socket && o.socket._httpMessage.writable == true;
-}
-function isRequest(o) {
-    return o instanceof Object && "socket" in o && "url" in o && "body" in o && "params" in o && "query" in o && "res" in o;
-}
-
-function isRequstHandlerArgs(args) {
-    const [_last1, last2, last3, ..._others] = [...args].reverse();
-    return isResponse(last2) && isRequest(last3);
-}
-
-function PassParam(paramName) {
-    return (actualHandler) => {
-        return (...args) => {
-            if (isRequstHandlerArgs(args)) {
-                const req = args.at(-3);
-                const res = args.at(-2);
-                const paramToPass = req.params[paramName];
-                return actualHandler(paramToPass)(req, res);
-            } else {
-                return (req, res) => {
-                    const paramToPass = req.params[paramName];
-                    actualHandler(...args, paramToPass)(req, res);
-                };
-            }
-        };
-    };
-}
-
-function PassQuery(searchQuery) {
-    return (actualHandler) => {
-        return (...args) => {
-            if (isRequstHandlerArgs(args)) {
-                const req = args.at(-3);
-                const res = args.at(-2);
-                const paramToPass = req.query[searchQuery];
-                return actualHandler(paramToPass)(req, res);
-            } else {
-                return (req, res) => {
-                    const paramToPass = req.query[searchQuery];
-                    actualHandler(...args, paramToPass)(req, res);
-                };
-            }
-        };
-    };
-}
-
-function PassAllParams(actualHandler) {
-    return (...args) => {
-        if (isRequstHandlerArgs(args)) {
-            const req = args.at(-3);
-            const res = args.at(-2);
-            return actualHandler(req.params)(req, res);
-        } else {
-            return (req, res) => actualHandler(...args, req.params)(req, res);
-        }
-    };
-}
-
-function PassAllQueries(actualHandler) {
-    return (...args) => {
-        if (isRequstHandlerArgs(args)) {
-            const req = args.at(-3);
-            const res = args.at(-2);
-            return actualHandler(req.query)(req, res);
-        } else {
-            return (req, res) => actualHandler(...args, req.query)(req, res);
-        }
-    };
-}
-
-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, config))(req, res);
-                } catch (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, config))(req, res);
-                    } catch (e) {
-                        const status = e.status ?? 500;
-                        status === 500 && log.error(e.stack);
-                        reply(res, status, e.message || e);
-                    }
-                };
-            }
-        };
-    };
-}
-
-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 {
-                    if (req.body === null || req.body === undefined) throw new HttpError(400, "Request body is mandatory");
-                    return actualHandler(asStrict(req.body, type, config))(req, res);
-                } catch (e) {
-                    const status = e.status ?? 500;
-                    status === 500 && log.error(e.stack);
-                    reply(res, status, e.message || e);
-                }
+function Needs() {
+    const argGetters = [];
+
+    const needs = {
+        param(name) {
+            argGetters.push((req) => req.params[name]);
+            return needs; // Return the object itself
+        },
+        params() {
+            argGetters.push((req) => req.params);
+            return needs;
+        },
+        query(name) {
+            argGetters.push((req) => req.query[name]);
+            return needs;
+        },
+        queries() {
+            argGetters.push((req) => req.query);
+            return needs;
+        },
+        body(type, config) {
+            if (type) {
+                argGetters.push((req) => asStrict(req.body || {}, type, config || { messageTemplate: "Malformed Request Body\n{0}" }));
             } else {
-                return (req, res) => {
-                    try {
-                        if (req.body === null || req.body === undefined) throw new HttpError(400, "Request body is mandatory");
-                        return actualHandler(...args, asStrict(req.body, type, config))(req, res);
-                    } catch (e) {
-                        const status = e.status ?? 500;
-                        status === 500 && log.error(e.stack);
-                        reply(res, status, e.message || e);
-                    }
-                };
-            }
-        };
-    };
-}
-
-function PassBody(actualHandler) {
-    return (...args) => {
-        if (isRequstHandlerArgs(args)) {
-            const req = args.at(-3);
-            const res = args.at(-2);
-            try {
-                return actualHandler(req.body)(req, res);
-            } catch (e) {
-                const status = e.status ?? 500;
-                status === 500 && log.error(e.stack);
-                reply(res, status, e.message || e);
+                argGetters.push((req) => req.body || {});
             }
-        } else {
+            return needs;
+        },
+        parseBody(type, config) {
+            argGetters.push((req) => as(req.body || {}, type, config || { messageTemplate: "Malformed Request Body\n{0}" }));
+            return needs;
+        },
+        cookie(name) {
+            argGetters.push((req) => req.cookies[name]);
+            return needs;
+        },
+        cookies() {
+            argGetters.push((req) => req.cookies);
+            return needs;
+        },
+        header(name) {
+            argGetters.push((req) => req.headers[name]);
+            return needs;
+        },
+        headers() {
+            argGetters.push((req) => req.headers);
+            return needs;
+        },
+        request() {
+            argGetters.push((req) => req)
+            return needs;
+        },
+        response() {
+            argGetters.push((_, res) => res)
+            return needs;
+        },
+        to(callback) {
             return (req, res) => {
-                try {
-                    return actualHandler(...args, req.body)(req, res);
-                } catch (e) {
-                    const status = e.status ?? 500;
-                    status === 500 && log.error(e.stack);
-                    reply(res, status, e.message || e);
-                }
+                const args = argGetters.map((getter) => getter(req, res));
+                return RestMethod(callback)(...args)(req, res);
             };
         }
     };
-}
 
-function PassRequest(actualHandler) {
-    return (...args) => {
-        if (isRequstHandlerArgs(args)) {
-            const req = args.at(-3);
-            const res = args.at(-2);
-            return actualHandler(req)(req, res);
-        } else {
-            return (req, res) => actualHandler(...args, req)(req, res);
-        }
-    };
-}
-
-function PassResponse(actualHandler) {
-    return (...args) => {
-        if (isRequstHandlerArgs(args)) {
-            const req = args.at(-3);
-            const res = args.at(-2);
-            return actualHandler(res)(req, res);
-        } else {
-            return (req, res) => actualHandler(...args, res)(req, res);
-        }
-    };
-}
-
-function PassAllCookies(actualHandler) {
-    return (...args) => {
-        if (isRequstHandlerArgs(args)) {
-            const req = args.at(-3);
-            const res = args.at(-2);
-            return actualHandler(req.cookies)(req, res);
-        } else {
-            return (req, res) => actualHandler(...args, req.cookies)(req, res);
-        }
-    };
-}
-
-function PassCookie(cookieName) {
-    return (actualHandler) => {
-        return (...args) => {
-            if (isRequstHandlerArgs(args)) {
-                const req = args.at(-3);
-                const res = args.at(-2);
-                const cookie = req.cookies[cookieName];
-                return actualHandler(cookie)(req, res);
-            } else {
-                return (req, res) => {
-                    const cookie = req.cookies[cookieName];
-                    actualHandler(...args, cookie)(req, res);
-                };
-            }
-        };
-    };
+    return needs;
 }
 
 module.exports = {
     RestService,
     RestMethod,
     Restify,
-    PassParam,
-    PassAllParams,
-    PassQuery,
-    PassAllQueries,
-    PassAllCookies,
-    PassCookie,
-    PassBody,
-    PassBodyAs,
-    ParseBodyAs,
-    PassRequest,
-    PassResponse,
+    Needs,
 };

package/package.json

@@ -1,38 +1,39 @@
-{
-  "name": "bootpress",
-  "version": "10.0.4",
-  "description": "REST service methods for express",
-  "main": "index.js",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/ufukbakan/bootpress.git"
-  },
-  "keywords": [
-    "bootpress",
-    "express",
-    "js",
-    "javascript",
-    "backend framework",
-    "backend",
-    "rest",
-    "service",
-    "methods",
-    "spring",
-    "boot",
-    "like"
-  ],
-  "author": "Ufuk Bakan",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/ufukbakan/bootpress/issues"
-  },
-  "homepage": "https://github.com/ufukbakan/bootpress#readme",
-  "dependencies": {
-    "express": "^4.18.2"
-  },
-  "devDependencies": {
-    "@types/express": "^4.17.17",
-    "eslint": "^8.55.0",
-    "typescript": "^4.9.5"
-  }
-}
+{
+  "name": "bootpress",
+  "version": "11.0.0-rc.2",
+  "description": "REST service methods for express",
+  "main": "index.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ufukbakan/bootpress.git"
+  },
+  "keywords": [
+    "bootpress",
+    "express",
+    "js",
+    "javascript",
+    "backend framework",
+    "backend",
+    "rest",
+    "service",
+    "methods",
+    "spring",
+    "boot",
+    "like"
+  ],
+  "author": "Ufuk Bakan",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/ufukbakan/bootpress/issues"
+  },
+  "homepage": "https://github.com/ufukbakan/bootpress#readme",
+  "dependencies": {
+    "express": "^4.18.2"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.17",
+    "eslint": "^8.55.0",
+    "typescript": "^4.9.5",
+    "vitest": "^4.0.18"
+  }
+}