bootpress 2.0.0 → 4.1.1

package/README.md

@@ -1,62 +1,90 @@
-<h1 align="center" style="margin-bottom: 0" >bootpress</h1>
-<p align=center>Express but SpringBoot like</p>
+<h1 align="center" style="margin-bottom: 0" >
+<img src="bootpress.svg" height=120 alt="bootpress">
+</h1>
+<p align=center>Express but Spring Boot like</p>
 
 ## Methods
-### **RestService**: Converts all methods to Express RequestHandlers
+### **<u>RestService</u>**: Converts all methods to Express RequestHandlers
 #### Basic usage:
 ```ts
+import express from "express";
+import bodyparser from "body-parser";
+import { HttpError, PassParams, RestService } from "bootpress";
+import { asInteger, getOrThrow } from "bootpress/helpers";
+
+const app = express();
+app.use(bodyparser.json());
+
 const UserServiceImpl = {
     users: [1, 2, 3, 4],
     findAllUsers(): number[] {
         return this.users;
     },
-    findUserById(id: number) {
-        return this.users.find(user => user == id);
+    findUserById(idInParams: string) {
+        const id = asInteger(idInParams);
+        return getOrThrow(this.users.find(user => user == id), new HttpError(404, "Not Found"));
     }
 };
 
 const UserService = RestService(UserServiceImpl);
 
-app.get("/users", UserService.findAllUsers);
-app.get("/users/:id", (req) => UserService.findUserById(+req.params.id));
+app.get("/users", UserService.findAllUsers());
+app.get("/users/:id", PassParams("id")(UserService.findUserById));
 ```
 
 #### Advanced usage:
 ```ts
+import { HttpError, HttpResponse, PassBody, PassParams, PassQueries, RestService } from "bootpress";
+import { asInteger, asSchema, getOrThrow } from "bootpress/helpers";
+
 class PostServiceImpl {
     posts = [1, 2, 3, 4, 5];
     findById(id: number | string) {
+        console.log("looking for " + id);
         return getOrThrow(
             this.posts.find(p => p == id),
             new HttpError(404, "Post is not found")
         );
     }
-    add(id: number) {
-        this.posts.push(id);
-        return new HttpResponse(201, id);
+    add(body: any) {
+        let casted = asSchema(body, {
+            "id": "number"
+        });
+        this.posts.push(casted.id);
+        return new HttpResponse(201, casted.id);
     }
-    delete(id: number) {
-        const idx = this.posts.indexOf(id);
+    delete(deleteInQuery: string, idInQuery: string) {
+        const idx = deleteInQuery === "yes" ? this.posts.indexOf(asInteger(idInQuery)) : -1;
         if (idx > -1) {
             this.posts.splice(idx, 1);
-            this.#printDeleted(id);
+            this.#printDeleted(idInQuery);
         }
     }
     // use private methods to  
     #printDeleted(id: number | string) {
         console.warn(`post ${id} is deleted`)
     }
+    findAll() {
+        return this.posts;
+    }
 }
 
-const PostService = RestService(new PostServiceImpl());
+const PostService = RestService(PostServiceImpl);
+// this is valid too:
+// const PostService = RestService(new PostServiceImpl());
 
-app.get("/posts/:id", (req) => PostService.findById(req.params.id));
-app.post("/posts/:id", (req) => PostService.add(+req.params.id));
+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));
 ```
 
-### **RestMethod**: Converts single method to RequestHandler
+### **<u>RestMethod</u>**: Converts single method to RequestHandler
 #### Usage:
 ```ts
+import { HttpError, RestMethod } from "bootpress";
+import { getOrThrow } from "bootpress/helpers";
+
 class UserService {
     users = [1, 2, 3, 4];
     findAll()  {
@@ -77,10 +105,13 @@ app.get("/users", userService.findAll())
 app.get("/users/:id", (req) => userService.findById(+req.params.id))
 ```
 
-### **Restify**: Decorator to convert a single method to RequestHandler
+### **<u>Restify</u>**: Decorator to convert a single method to RequestHandler
 #### Note that currently decorators in Typescript doesn't support changing the return type of applied method. So you have to provide RequestHandler as an "or type":
 
 ```ts
+import { Restify } from "bootpress";
+import { RequestHandler } from "express";
+
 class LogServiceImpl {
     logs = ["log1", "log2", "log3"];
 

package/helpers/index.d.ts

@@ -1,3 +1,23 @@
 import { HttpError } from "..";
 
+type TypeMap = {
+    "string": string,
+    "string?": string | null,
+    "boolean": boolean,
+    "boolean?": boolean | null,
+    "number": number,
+    "number?": number | null,
+}
+
+type JsSchema = {
+    [key: string]: keyof TypeMap | JsSchema
+}
+
+type SchemadRecord<T> = { [E in keyof T]: T[E] extends string ? TypeMap[T[E]] : SchemadRecord<T[E]> };
+
 export function getOrThrow<T, E extends HttpError>(data: T, error: E): T;
+export function getOrElse<T, E>(data: T, defaultValue: E): T | E;
+export function asBoolean(o: any): boolean;
+export function asNumber(o: any): number;
+export function asInteger(o: any): number;
+export function asSchema<T extends JsSchema>(o: any, jsSchema: T): SchemadRecord<T>

package/helpers/index.js

@@ -1,11 +1,100 @@
-function getOrThrow(data, error){
-    if(data === null || data === undefined){
+const { HttpError } = require("..");
+
+function getOrThrow(data, error) {
+    if (data === null || data === undefined) {
         throw error;
-    }else{
+    } else {
+        return data;
+    }
+}
+
+function getOrElse(data, defaultValue) {
+    if (data === null || data === undefined) {
+        return defaultValue;
+    } else {
         return data;
     }
 }
 
+function asBoolean(o, errorMessage = undefined, errorStatus = 400) {
+    errorMessage = errorMessage ?? `Value ${o} should have been a boolean but it's not`;
+    if (typeof o === "string") {
+        const lowercased = o.toLowerCase();
+        const validBooleanStrings = new Map(Object.entries({
+            "true": true,
+            "false": false,
+            "1": true,
+            "0": false,
+            "yes": true,
+            "no": false
+        }));
+        if (!validBooleanStrings.has(lowercased)) {
+            throw new HttpError(errorStatus, errorMessage);
+        }
+        return validBooleanStrings.get(lowercased);
+    } else if (typeof o === "boolean") {
+        return o;
+    }
+    throw new HttpError(errorStatus, errorMessage);
+}
+
+function asNumber(o, errorMessage = undefined, errorStatus = 400) {
+    errorMessage = errorMessage ?? `Value ${o} should have been a number but it's not`
+    if (typeof o === "number") {
+        return o;
+    }
+    else if (typeof o === "string") {
+        const castedValue = Number(o);
+        if (isNaN(castedValue)) {
+            throw new HttpError(errorStatus, errorMessage);
+        }
+    }
+    throw new HttpError(errorStatus, errorMessage);
+}
+
+function asInteger(o, errorMessage = undefined, errorStatus = 400) {
+    errorMessage = errorMessage ?? `Value ${o} should have been a integer but it's not`;
+    let value = o;
+    if (typeof o === "string") {
+        value = Number(o);
+    }
+    if (!Number.isInteger(value)) {
+        throw new HttpError(errorStatus, errorMessage);
+    }
+    return value;
+}
+
+function asSchema(o, schema){
+    const schemaKeyValues = Object.entries(schema);
+    for(let i = 0; i < schemaKeyValues.length; i ++){
+        const key = schemaKeyValues[i][0];
+        const expectedType = schemaKeyValues[i][1];
+        const errorMessage = `Value of ${key} should have been a ${expectedType} but it's a ${typeof o[key]}`;
+
+        if(typeof expectedType === "object"){
+            asSchema(o[key], expectedType);
+        }
+        else if(typeof expectedType === "string"){
+            if(expectedType.endsWith("?") && o[key] == null){
+                continue;
+            }
+            expectedType.replace("?", "");
+            if(typeof o[key] !== expectedType){
+                throw new HttpError(400, errorMessage);
+            }
+        }
+        else {
+            throw new HttpError(500, `Type of a schema key should be a primitive type or another schema`);
+        }
+    }
+    return o;
+}
+
 module.exports = {
-    getOrThrow
+    getOrThrow,
+    getOrElse,
+    asBoolean,
+    asNumber,
+    asInteger,
+    asSchema
 }

package/index.d.ts

@@ -1,4 +1,8 @@
-import { RequestHandler } from "express"
+import { Response } from "express"
+import { Request } from "express"
+
+type RequestHandler = (req: Request, res: Response) => void
+type RequsetHandlerWithArgs = (...args: any[]) => RequestHandler
 
 declare class HttpError extends Error {
     status: number
@@ -14,18 +18,36 @@ declare class HttpResponse<T> {
 
 type RestedService<T extends Record<string, any>> = { [K in keyof T]:
     T[K] extends Function
-    ? (...args: Parameters<T[K]>) => ((req: Request, res: Response) => void)
+    ? (...args: Parameters<T[K]>) => RequestHandler
     : T[K]
 }
 
+declare function RestService<T extends Record<string, any>>(clazz: new () => T): RestedService<T>;
 declare function RestService<T extends Record<string, any>>(service: T): RestedService<T>;
 declare function RestMethod<T>(callback: () => T): RequestHandler;
 declare function Restify(target: any, key: string, desc: PropertyDescriptor): PropertyDescriptor;
 
+declare function PassBody(serviceFunction: RequestHandler | RequsetHandlerWithArgs): RequestHandler
+declare function PassRequest(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
+
 export {
     HttpError,
     HttpResponse,
     RestService,
     RestMethod,
-    Restify
+    Restify,
+    PassParams,
+    PassAllParams,
+    PassQueries,
+    PassAllQueries,
+    PassCookies,
+    PassAllCookies,
+    PassBody,
+    PassRequest
 }

package/index.js

@@ -14,27 +14,57 @@ class HttpResponse {
     }
 }
 
+const protectedProperties = [
+    "toString",
+    "toJSON",
+    "valueOf",
+    "toLocaleString"
+]
+
 function RestService(service) {
-    return Object.fromEntries(
-        Object.entries(service).map(keyvalue => {
-            if (typeof keyvalue[1] == "function") {
-                return [
-                    keyvalue[0],
-                    (...args) =>
+    if (typeof service == "function") {
+        try {
+            service = service();
+        } catch (e) {
+            service = new service();
+        }
+    }
+    const descriptors = {
+        ...Object.getOwnPropertyDescriptors(service),
+        ...Object.getOwnPropertyDescriptors(service.__proto__ || {})
+    };
+    const alteredDescriptors = Object.fromEntries(Object.entries(descriptors).filter(keyvalue => !protectedProperties.includes(keyvalue[0])).map(keyvalue => {
+        const propertyName = keyvalue[0];
+        const value = keyvalue[1].value;
+        if (typeof value == "function" && !propertyName.startsWith("#")) {
+            return [
+                propertyName,
+                {
+                    value: ((...args) =>
                         (req, res) => {
                             try {
-                                const result = keyvalue[1](...args);
+                                const result = value.bind(service)(...args);
+                                if (result === undefined) {
+                                    throw new HttpError(200, "Your method is executed but it returned undefined. Please avoid using 'void' methods as service methods.");
+                                } else if (result === null) {
+                                    throw new HttpError(200, "Your method is executed but it returned null. At least a value is expected to be returned.");
+                                }
                                 res.status(result.status || 200).json(result.data || result);
                             } catch (e) {
-                                res.status(e.status || 500).json(e.message || e);
+                                res.status(e.status || 500).send(e.message || e);
                             }
-                        }
-                ]
-            } else {
-                return keyvalue;
-            }
-        })
-    );
+                        }),
+                    configurable: keyvalue[1].configurable,
+                    writable: keyvalue[1].writable,
+                    enumerable: false
+                }
+            ]
+        } else {
+            return keyvalue;
+        }
+    }));
+    Object.defineProperties(service, alteredDescriptors);
+    return service;
 }
 
 function RestMethod(callback) {
@@ -53,7 +83,7 @@ function Restify(target, key, desc) {
     const oldFunc = desc.value;
     return {
         ...desc,
-        value: (...args) => {
+        value: ((...args) => {
             return (req, res) => {
                 try {
                     const result = oldFunc(...args);
@@ -63,6 +93,116 @@ function Restify(target, key, desc) {
                     res.status(e.status || 500).json(e.message || e);
                 }
             }
+        }).bind(target)
+    }
+}
+
+
+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 PassParams(...paramNames) {
+    return (actualHandler) => {
+        return (...args) => {
+            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);
+            } else {
+                return (req, res) => { const paramsToPass = paramNames.map(paramName => req.params[paramName]); return actualHandler(...args, ...paramsToPass)(req, res); };
+            }
+        }
+    }
+}
+
+function PassQueries(...searchQueries) {
+    return (actualHandler) => {
+        return (...args) => {
+            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);
+            } else {
+                return (req, res) => { const paramsToPass = searchQueries.map(query => req.query[query]); return actualHandler(...args, ...paramsToPass)(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 PassBody(actualHandler) {
+    return (...args) => {
+        if (isRequstHandlerArgs(args)) {
+            const req = args.at(-3); const res = args.at(-2);
+            return actualHandler(req.body)(req, res);
+        } else {
+            return (req, res) => actualHandler(...args, req.body)(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 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 PassCookies(...cookieNames) {
+    return (actualHandler) => {
+        return (...args) => {
+            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);
+            } else {
+                return (req, res) => { const paramsToPass = cookieNames.map(cookie => req.cookies[cookie]); return actualHandler(...args, ...paramsToPass)(req, res) };
+            }
         }
     }
 }
@@ -72,5 +212,13 @@ module.exports = {
     HttpResponse,
     RestService,
     RestMethod,
-    Restify
+    Restify,
+    PassParams,
+    PassAllParams,
+    PassQueries,
+    PassAllQueries,
+    PassAllCookies,
+    PassCookies,
+    PassBody,
+    PassRequest
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bootpress",
-  "version": "2.0.0",
+  "version": "4.1.1",
   "description": "REST service methods for express",
   "main": "index.js",
   "scripts": {},
@@ -24,10 +24,10 @@
     "url": "https://github.com/ufukbakan/bootpress/issues"
   },
   "homepage": "https://github.com/ufukbakan/bootpress#readme",
-  "devDependencies": {
-    "@types/express": "^4.17.17"
-  },
   "dependencies": {
+    "@types/body-parser": "^1.19.2",
+    "@types/express": "^4.17.17",
+    "body-parser": "^1.20.2",
     "express": "^4.18.2"
   }
 }