bootpress 5.0.1 → 6.0.1

package/README.md

@@ -1,8 +1,11 @@
 <h1 align="center" style="margin-bottom: 0" >
-<img src="bootpress.svg" height=120 alt="bootpress">
+<img src="https://raw.githubusercontent.com/ufukbakan/bootpress/main/bootpress.svg" height=120 alt="bootpress">
 </h1>
 <p align=center>Express but Spring Boot like</p>
 
+## Quick Start
+Recommended tool: [create-bootpress-app](https://www.npmjs.com/package/create-bootpress-app)
+
 ## Methods
 ### **<u>RestService</u>**: Converts all methods to Express RequestHandlers
 #### Basic usage:

package/helpers/index.d.ts

@@ -1,4 +1,4 @@
-import { HttpError } from "..";
+import { HttpError } from "../types";
 
 type TypeMap = {
     "string": string,
@@ -10,7 +10,7 @@ type TypeMap = {
 }
 
 type ValidTypeKeys = keyof TypeMap;
-type ValOf<T extends keyof TypeMap> = TypeMap[T]
+type ValOf<T extends ValidTypeKeys> = TypeMap[T]
 
 type StringEndsWithQm = `${string}?`;
 
@@ -35,4 +35,27 @@ export function asNumber(o: any): number;
 export function asInteger(o: any): number;
 export function asString(o: any): string;
 export function asSchema<T extends JsSchema>(o: any, jsSchema: T): TypedSchema<T>;
-export function schema<T extends JsSchema>(schema: T): T;
+export function schema<T extends JsSchema>(schema: T): T;
+
+type ExtendedTypeMap = {
+    "string": string,
+    "string[]": string[],
+    "boolean": boolean,
+    "boolean[]": boolean[],
+    "number": number,
+    "number[]": number[],
+    "integer": number,
+    "integer[]": number[],
+    "string?": string | null,
+    "string[]?": string[] | null,
+    "boolean?": boolean | null,
+    "boolean[]?": boolean[] | null,
+    "number?": number | null,
+    "number[]?": number[] | null,
+    "integer?": number | null,
+    "integer[]?": number[] | null
+}
+
+type ExtendedTypeKeys = keyof ExtendedTypeMap;
+type ExtValOf<T extends ExtendedTypeKeys> = ExtendedTypeMap[T]
+export function as<T extends (ExtendedTypeKeys | JsSchema | ArraySchema)>(o:any, schema: T): T extends ExtendedTypeKeys ? ExtValOf<T> : TypedSchema<T>;

package/helpers/index.js

@@ -1,4 +1,4 @@
-const { HttpError } = require("..");
+const { HttpError } = require("../types");
 
 function getOrThrow(data, error) {
     if (data === null || data === undefined) {
@@ -34,6 +34,9 @@ function asBoolean(o, errorMessage = undefined, errorStatus = 400) {
         return validBooleanStrings.get(lowercased);
     } else if (typeof o === "boolean") {
         return o;
+    } else if (typeof o === "number"){
+        if(o === 1) return true;
+        if(o === 0) return false;
     }
     throw new HttpError(errorStatus, errorMessage);
 }
@@ -102,8 +105,8 @@ function asSchema(o, schema) {
         else if (typeof expectedType === "string") {
             if (expectedType.endsWith("[]")) {
                 const elementType = expectedType.replace("[]", "");
-                for (let j = 0; j < o[key].length; j++){
-                    if(typeof o[key][j] !== elementType){
+                for (let j = 0; j < o[key].length; j++) {
+                    if (typeof o[key][j] !== elementType) {
                         throw new HttpError(400, `Each element of ${key} should have been a ${elementType} but a ${typeof o[key][j]} is present (${o[key][j]})`);
                     }
                 }
@@ -127,6 +130,73 @@ function schema(schema) {
     return schema;
 }
 
+function asArrayOf(o, elementType) {
+    if (Array.isArray(o)) {
+        for (let i = 0; i < o.length; i++) {
+            if(elementType === "integer"){
+                asInteger(o[i]);
+            }else if(typeof o[i] != elementType){
+                throw new HttpError(400, `Each element in array should have been a ${elementType} but ${o[i]} is present with type ${typeof o[i]}`);
+            }
+        }
+        return o;
+    } else {
+        throw new HttpError(400, `Provided object is not an array: ${JSON.stringify(o)}`)
+    }
+}
+
+function as(o, type) {
+    if (typeof type == "string") {
+        if (type.endsWith("[]")) {
+            // array check
+            const elementType = type.replace("[]", "");
+            return asArrayOf(o, elementType);
+        } else {
+            if(type.endsWith("?") && o == null){
+                return null;
+            }else if(type.endsWith("?") && o != null ){
+                const actualType = type.replace("?", "");
+                return as(o, actualType);
+            }
+            // primitive check
+            switch (type) {
+                case "string":
+                    return asString(o);
+                case "number":
+                    return asNumber(o);
+                case "boolean":
+                    return asBoolean(o);
+                case "integer":
+                    return asInteger(o);
+                default:
+                    throw new HttpError(500, `Unsupported type ${type}`);
+            }
+        }
+    } 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>`);
+            }else if (type.length < 1){
+                throw new HttpError(500, `You must define a schema for types ArrayOf<Schema>`);
+            }
+            // array schema validation
+            if(!Array.isArray(o)){
+                throw new HttpError(400, `Provided value should have been an array. (${JSON.stringify(o)})`)
+            }
+            const providedSchema = type[0];
+            for(let i = 0; i < o.length; i++){
+                asSchema(o[i], providedSchema);
+            }
+            return o;
+        } else {
+            // schema validation
+            return asSchema(o, type);
+        }
+    } else {
+        throw new HttpError(500, `Unsupported type check ${type}`)
+    }
+}
+
 module.exports = {
     getOrThrow,
     getOrElse,
@@ -135,5 +205,6 @@ module.exports = {
     asInteger,
     asString,
     asSchema,
-    schema
+    schema,
+    as
 }

package/index.d.ts

@@ -1,21 +1,9 @@
-import { Response } from "express"
-import { Request } from "express"
+import { Response, Request } from "express"
+import { ArraySchema, JsSchema, ValidTypeKeys } from "./helpers"
 
 type RequestHandler = (req: Request, res: Response) => void
 type RequsetHandlerWithArgs = (...args: any[]) => RequestHandler
 
-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]>) => RequestHandler
@@ -28,17 +16,17 @@ 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 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 PassCookies(...cookieNames: string[]): (serviceFunction: RequestHandler | RequsetHandlerWithArgs) => RequestHandler
+declare function PassRequest(serviceFunction: RequestHandler | RequsetHandlerWithArgs): RequestHandler
+declare function PassResponse(serviceFunction: RequestHandler | RequsetHandlerWithArgs): RequestHandler
 
 export {
-    HttpError,
-    HttpResponse,
     RestService,
     RestMethod,
     Restify,
@@ -49,5 +37,7 @@ export {
     PassCookies,
     PassAllCookies,
     PassBody,
-    PassRequest
+    PassBodyAs,
+    PassRequest,
+    PassResponse
 }

package/index.js

@@ -1,18 +1,5 @@
-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;
-    }
-}
+const { as } = require("./helpers");
+const { HttpError } = require("./types");
 
 const protectedProperties = [
     "toString",
@@ -21,6 +8,14 @@ const protectedProperties = [
     "toLocaleString"
 ]
 
+function reply(res, status, data) {
+    if (typeof data == "object") {
+        res.status(status).json(data);
+    } else {
+        res.status(status).send(data);
+    }
+}
+
 function RestService(service) {
     if (typeof service == "function") {
         try {
@@ -49,9 +44,9 @@ function RestService(service) {
                                 } 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);
+                                reply(res, result.status || 200, result.data || result)
                             } catch (e) {
-                                res.status(e.status || 500).send(e.message || e);
+                                reply(res, e.status || 500, e.message || e);
                             }
                         }),
                     configurable: keyvalue[1].configurable,
@@ -71,10 +66,10 @@ function RestMethod(callback) {
     return (req, res) => {
         try {
             const result = callback();
-            res.status(result.status || 200).json(result.data || result);
+            reply(res, result.status || 200, result.data || result);
             return result;
         } catch (e) {
-            res.status(e.status || 500).json(e.message || e);
+            reply(res, e.status || 500, e.message || e)
         }
     }
 }
@@ -87,10 +82,10 @@ function Restify(target, key, desc) {
             return (req, res) => {
                 try {
                     const result = oldFunc(...args);
-                    res.status(result.status || 200).json(result.data || result);
+                    reply(res, result.status || 200, result.data || result);
                     return result;
                 } catch (e) {
-                    res.status(e.status || 500).json(e.message || e);
+                    reply(res, e.status || 500, e.message || e);
                 }
             }
         }).bind(target)
@@ -171,6 +166,30 @@ function PassBody(actualHandler) {
     }
 }
 
+function PassBodyAs(type) {
+    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);
+                } catch (e) {
+                    reply(res, e.status || 500, e.message || e);
+                }
+
+            } else {
+                return (req, res) => {
+                    try{
+                        return actualHandler(...args, as(req.body, type))(req, res);
+                    }catch(e){
+                        reply(res, e.status || 500, e.message || e)
+                    }
+                }
+            }
+        }
+    }
+}
+
 function PassRequest(actualHandler) {
     return (...args) => {
         if (isRequstHandlerArgs(args)) {
@@ -182,6 +201,17 @@ function PassRequest(actualHandler) {
     }
 }
 
+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)) {
@@ -208,8 +238,6 @@ function PassCookies(...cookieNames) {
 }
 
 module.exports = {
-    HttpError,
-    HttpResponse,
     RestService,
     RestMethod,
     Restify,
@@ -220,5 +248,7 @@ module.exports = {
     PassAllCookies,
     PassCookies,
     PassBody,
-    PassRequest
+    PassBodyAs,
+    PassRequest,
+    PassResponse
 }

package/package.json

@@ -1,9 +1,8 @@
 {
   "name": "bootpress",
-  "version": "5.0.1",
+  "version": "6.0.1",
   "description": "REST service methods for express",
   "main": "index.js",
-  "scripts": {},
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ufukbakan/bootpress.git"
@@ -28,7 +27,7 @@
     "express": "^4.18.2"
   },
   "devDependencies": {
-    "@types/body-parser": "^1.19.2",
-    "@types/express": "^4.17.17"
+    "@types/express": "^4.17.17",
+    "typescript": "^4.9.5"
   }
 }

package/types/index.js

@@ -0,0 +1,20 @@
+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;
+    }
+}
+
+module.exports = {
+    HttpError,
+    HttpResponse
+}

package/types/index.ts

@@ -0,0 +1,16 @@
+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)
+}
+
+export {
+    HttpError,
+    HttpResponse
+}