bootpress 2.0.0

package/README.md

@@ -0,0 +1,96 @@
+<h1 align="center" style="margin-bottom: 0" >bootpress</h1>
+<p align=center>Express but SpringBoot like</p>
+
+## Methods
+### **RestService**: Converts all methods to Express RequestHandlers
+#### Basic usage:
+```ts
+const UserServiceImpl = {
+    users: [1, 2, 3, 4],
+    findAllUsers(): number[] {
+        return this.users;
+    },
+    findUserById(id: number) {
+        return this.users.find(user => user == id);
+    }
+};
+
+const UserService = RestService(UserServiceImpl);
+
+app.get("/users", UserService.findAllUsers);
+app.get("/users/:id", (req) => UserService.findUserById(+req.params.id));
+```
+
+#### Advanced usage:
+```ts
+class PostServiceImpl {
+    posts = [1, 2, 3, 4, 5];
+    findById(id: number | string) {
+        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);
+    }
+    delete(id: number) {
+        const idx = this.posts.indexOf(id);
+        if (idx > -1) {
+            this.posts.splice(idx, 1);
+            this.#printDeleted(id);
+        }
+    }
+    // use private methods to  
+    #printDeleted(id: number | string) {
+        console.warn(`post ${id} is deleted`)
+    }
+}
+
+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));
+```
+
+### **RestMethod**: Converts single method to RequestHandler
+#### Usage:
+```ts
+class UserService {
+    users = [1, 2, 3, 4];
+    findAll()  {
+        return RestMethod(() => {
+            return this.users;
+        })
+    }
+    findById(id: number) {
+        return RestMethod(() => {
+            return getOrThrow(this.users.find(u => u == id), new HttpError(404, "Not Found"));
+        })
+    }
+}
+
+const userService = new UserService();
+
+app.get("/users", userService.findAll())
+app.get("/users/:id", (req) => userService.findById(+req.params.id))
+```
+
+### **Restify**: 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
+class LogServiceImpl {
+    logs = ["log1", "log2", "log3"];
+
+    @Restify
+    findAll(): string[] | RequestHandler {
+        return this.logs;
+    }
+}
+
+const LogService = new LogServiceImpl();
+
+app.get("/logs", LogService.findAll() as RequestHandler)
+```

package/helpers/index.d.ts

@@ -0,0 +1,3 @@
+import { HttpError } from "..";
+
+export function getOrThrow<T, E extends HttpError>(data: T, error: E): T;

package/helpers/index.js

@@ -0,0 +1,11 @@
+function getOrThrow(data, error){
+    if(data === null || data === undefined){
+        throw error;
+    }else{
+        return data;
+    }
+}
+
+module.exports = {
+    getOrThrow
+}

package/index.d.ts

@@ -0,0 +1,31 @@
+import { RequestHandler } from "express"
+
+declare class HttpError extends Error {
+    status: number
+    message: string
+    constructor(status: number, message: string)
+}
+
+declare class HttpResponse<T> {
+    status: number
+    data: T
+    constructor(status: number, data: 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)
+    : T[K]
+}
+
+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;
+
+export {
+    HttpError,
+    HttpResponse,
+    RestService,
+    RestMethod,
+    Restify
+}

package/index.js

@@ -0,0 +1,76 @@
+class HttpError extends Error {
+    constructor(status, message) {
+        super(message);
+        this.stack += "\n" + message;
+        this.message = message;
+        this.status = status;
+    }
+}
+
+class HttpResponse {
+    constructor(status, data) {
+        this.status = status;
+        this.data = data;
+    }
+}
+
+function RestService(service) {
+    return Object.fromEntries(
+        Object.entries(service).map(keyvalue => {
+            if (typeof keyvalue[1] == "function") {
+                return [
+                    keyvalue[0],
+                    (...args) =>
+                        (req, res) => {
+                            try {
+                                const result = keyvalue[1](...args);
+                                res.status(result.status || 200).json(result.data || result);
+                            } catch (e) {
+                                res.status(e.status || 500).json(e.message || e);
+                            }
+                        }
+                ]
+            } else {
+                return keyvalue;
+            }
+        })
+    );
+}
+
+function RestMethod(callback) {
+    return (req, res) => {
+        try {
+            const result = callback();
+            res.status(result.status || 200).json(result.data || result);
+            return result;
+        } catch (e) {
+            res.status(e.status || 500).json(e.message || e);
+        }
+    }
+}
+
+function Restify(target, key, desc) {
+    const oldFunc = desc.value;
+    return {
+        ...desc,
+        value: (...args) => {
+            return (req, res) => {
+                try {
+                    const result = oldFunc(...args);
+                    res.status(result.status || 200).json(result.data || result);
+                    return result;
+                } catch (e) {
+                    res.status(e.status || 500).json(e.message || e);
+                }
+            }
+        }
+    }
+}
+
+module.exports = {
+    HttpError,
+    HttpResponse,
+    RestService,
+    RestMethod,
+    Restify
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "bootpress",
+  "version": "2.0.0",
+  "description": "REST service methods for express",
+  "main": "index.js",
+  "scripts": {},
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ufukbakan/bootpress.git"
+  },
+  "keywords": [
+    "bootpress",
+    "express",
+    "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",
+  "devDependencies": {
+    "@types/express": "^4.17.17"
+  },
+  "dependencies": {
+    "express": "^4.18.2"
+  }
+}