bootpress 8.0.1 → 9.0.0

package/README.md

@@ -17,7 +17,7 @@ If you want to explicitly specify a field named 'data' or 'status' it's recommen
 #### Basic usage:
 ```ts
 import express from "express";
-import { HttpError, PassParams, RestService } from "bootpress";
+import { HttpError, PassParam, RestService } from "bootpress";
 import { as, getOrThrow } from "bootpress/helpers";
 
 const app = express();
@@ -28,7 +28,7 @@ const UserServiceImpl = {
     findAllUsers(): number[] {
         return this.users;
     },
-    findUserById(idInParams: string) {
+    findUserById(idInParams: string | undefined) {
         const id = as(idInParams, "integer");
         return getOrThrow(this.users.find(user => user === id), new HttpError(404, "Not Found"));
     }
@@ -37,12 +37,12 @@ const UserServiceImpl = {
 const UserService = RestService(UserServiceImpl);
 
 app.get("/users", UserService.findAllUsers());
-app.get("/users/:id", PassParams("id")(UserService.findUserById));
+app.get("/users/:id", PassParam("id")(UserService.findUserById));
 ```
 
 #### Advanced usage:
 ```ts
-import { HttpError, HttpResponse, PassBody, PassParams, PassQueries, RestService } from "bootpress";
+import { HttpError, HttpResponse, PassBody, PassParam, PassQuery, RestService } from "bootpress";
 import { as, asStrict, getOrThrow } from "bootpress/helpers";
 
 class PostServiceImpl {
@@ -60,7 +60,7 @@ class PostServiceImpl {
         this.posts.push(casted.id);
         return new HttpResponse(201, casted.id);
     }
-    delete(deleteInQuery: string, idInQuery: string) {
+    delete(deleteInQuery: string | undefined, idInQuery: string | undefined) {
         const idx = deleteInQuery === "yes" ? this.posts.indexOf(as(idInQuery, "integer")) : -1;
         if (idx > -1) {
             this.#logDeleted(idInQuery);
@@ -84,8 +84,8 @@ const PostService = RestService(PostServiceImpl);
 
 app.get("/posts", PostService.findAll())
 app.post("/posts", PassBody(PostService.add));
-app.delete("/posts", PassQueries("delete", "id")(PostService.delete));
-app.get("/posts/:id", PassParams("id")(PostService.findById));
+app.delete("/posts", PassQuery("delete")(PassQuery("id")(PostService.delete)));
+app.get("/posts/:id", PassParam("id")(PostService.findById));
 ```
 
 ### **<u>RestMethod</u>**: Converts single method to RequestHandler
@@ -149,11 +149,11 @@ app.get("/logs", LogService.findAll() as RequestHandler)
 
 ```PassAllCookies(serviceFunction)``` -> Passes cookies to service function as Record<string, string>
 
-```PassParams(...paramNames)(serviceFunction)``` -> Passes specified parameters as arguments to service function
+```PassParam(pathParam)(serviceFunction)``` -> Passes specified parameter as arguments to service function
 
-```PassQueries(...queryNames)(serviceFunction)``` -> Passes specified queries as arguments to service function
+```PassQuery(searchQueryName)(serviceFunction)``` -> Passes specified query as arguments to service function
 
-```PassCookies(...cookieNames)(serviceFunction)``` -> Passes specified cookies as arguments to service function
+```PassCookie(cookieName)(serviceFunction)``` -> Passes specified cookie as arguments to service function
 
 ```PassRequest(serviceFunction)``` -> Passes express request object to service function
 
@@ -219,6 +219,15 @@ There must be only one element in an array schema which defines ````ArrayOf<Sche
 ### **asStrict(any, string | object | array)**
 Same as 'as' method but doesn't try to parse different types instead throws error.
 
+## v9.0.0 Release Notes:
+- New Feature:
+  - Type checking for each argument while passing arguments to service methods
+- Deprecated:
+  - PassQueries, PassCookies, PassParams
+  - Please use PassAllQueries, PassAllCookies or PassAllParams
+- Added:
+  - PassQuery, PassCookie, PassParam
+
 ## v8.0.0 Release Notes:
 - Added support for async service functions. (You don't need to await if you wrapped your service with Bootpress functions)
 - Bugfix for falsy response values

package/index.d.ts

@@ -1,8 +1,11 @@
 import { Response, Request } from "express"
-import { ArraySchema, JsSchema, ValidTypeKeys } from "./helpers"
+import { ArraySchema, JsSchema, ValidTypeKeys, TypedSchema } from "./helpers"
 
 type RequestHandler = (req: Request, res: Response) => void
-type RequsetHandlerWithArgs = (...args: any[]) => RequestHandler
+type RequsetHandlerWithArgs = <A extends any[]>(...args: A) => RequestHandler
+type RequsetHandlerWithFirstArg<T> = (arg1: T, ...rest: any[]) => 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 RestedService<T extends Record<PropertyKey, any>> = { [K in keyof T]:
     T[K] extends Function
@@ -16,27 +19,27 @@ declare function RestService<T extends Record<PropertyKey, any>>(service: Instan
 declare function RestMethod<T>(callback: () => T): RequestHandler;
 declare function Restify(target: any, key: PropertyKey, desc: PropertyDescriptor): PropertyDescriptor;
 
-declare function PassBody(serviceFunction: RequestHandler | RequsetHandlerWithArgs): RequestHandler
-declare function ParseBodyAs(type: ValidTypeKeys | JsSchema | ArraySchema ): (serviceFunction: RequestHandler | RequsetHandlerWithArgs) => RequestHandler
-declare function PassBodyAs(type: ValidTypeKeys | JsSchema | ArraySchema ): (serviceFunction: RequestHandler | RequsetHandlerWithArgs) => RequestHandler
-declare function PassAllParams(serviceFunction: RequestHandler | RequsetHandlerWithArgs): RequestHandler
-declare function PassAllQueries(serviceFunction: RequestHandler | RequsetHandlerWithArgs): RequestHandler
-declare function PassAllCookies(serviceFunction: RequestHandler | RequsetHandlerWithArgs): RequestHandler
-declare function PassParams(...paramNames: string[]): (serviceFunction: RequestHandler | RequsetHandlerWithArgs) => RequestHandler
-declare function PassQueries(...queryNames: string[]): (serviceFunction: RequestHandler | RequsetHandlerWithArgs) => RequestHandler
-declare function PassCookies(...cookieNames: string[]): (serviceFunction: RequestHandler | RequsetHandlerWithArgs) => RequestHandler
-declare function PassRequest(serviceFunction: RequestHandler | RequsetHandlerWithArgs): RequestHandler
-declare function PassResponse(serviceFunction: RequestHandler | RequsetHandlerWithArgs): RequestHandler
+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>
 
 export {
     RestService,
     RestMethod,
     Restify,
-    PassParams,
+    PassParam,
     PassAllParams,
-    PassQueries,
+    PassQuery,
     PassAllQueries,
-    PassCookies,
+    PassCookie,
     PassAllCookies,
     PassBody,
     PassBodyAs,

package/index.js

@@ -124,29 +124,29 @@ function isRequstHandlerArgs(args) {
     return isResponse(last2) && isRequest(last3);
 }
 
-function PassParams(...paramNames) {
+function PassParam(paramName) {
     return (actualHandler) => {
         return (...args) => {
+            const paramToPass = req.params[paramName];
             if (isRequstHandlerArgs(args)) {
                 const req = args.at(-3); const res = args.at(-2);
-                const paramsToPass = paramNames.map(paramName => req.params[paramName]);
-                return actualHandler(...paramsToPass)(req, res);
+                return actualHandler(paramToPass)(req, res);
             } else {
-                return (req, res) => { const paramsToPass = paramNames.map(paramName => req.params[paramName]); return actualHandler(...args, ...paramsToPass)(req, res); };
+                return (req, res) => actualHandler(...args, paramToPass)(req, res);
             }
         }
     }
 }
 
-function PassQueries(...searchQueries) {
+function PassQuery(searchQuery) {
     return (actualHandler) => {
         return (...args) => {
+            const paramToPass = req.query[searchQuery];
             if (isRequstHandlerArgs(args)) {
                 const req = args.at(-3); const res = args.at(-2);
-                const paramsToPass = searchQueries.map(query => req.query[query]);
-                return actualHandler(...paramsToPass)(req, res);
+                return actualHandler(paramToPass)(req, res);
             } else {
-                return (req, res) => { const paramsToPass = searchQueries.map(query => req.query[query]); return actualHandler(...args, ...paramsToPass)(req, res); };
+                return (req, res) => actualHandler(...args, paramToPass)(req, res);
             }
         }
     }
@@ -277,15 +277,15 @@ function PassAllCookies(actualHandler) {
     }
 }
 
-function PassCookies(...cookieNames) {
+function PassCookie(cookieName) {
     return (actualHandler) => {
         return (...args) => {
+            const cookie = req.cookies[cookieName];
             if (isRequstHandlerArgs(args)) {
                 const req = args.at(-3); const res = args.at(-2);
-                const paramsToPass = cookieNames.map(cookie => req.cookies[cookie]);
-                return actualHandler(...paramsToPass)(req, res);
+                return actualHandler(cookie)(req, res);
             } else {
-                return (req, res) => { const paramsToPass = cookieNames.map(cookie => req.cookies[cookie]); return actualHandler(...args, ...paramsToPass)(req, res) };
+                return (req, res) => actualHandler(...args, cookie)(req, res);
             }
         }
     }
@@ -295,12 +295,12 @@ module.exports = {
     RestService,
     RestMethod,
     Restify,
-    PassParams,
+    PassParam,
     PassAllParams,
-    PassQueries,
+    PassQuery,
     PassAllQueries,
     PassAllCookies,
-    PassCookies,
+    PassCookie,
     PassBody,
     PassBodyAs,
     ParseBodyAs,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bootpress",
-  "version": "8.0.1",
+  "version": "9.0.0",
   "description": "REST service methods for express",
   "main": "index.js",
   "repository": {