bootpress 6.0.1 → 7.0.0

package/README.md

@@ -12,7 +12,7 @@ Recommended tool: [create-bootpress-app](https://www.npmjs.com/package/create-bo
 ```ts
 import express from "express";
 import { HttpError, PassParams, RestService } from "bootpress";
-import { asInteger, getOrThrow } from "bootpress/helpers";
+import { as, getOrThrow } from "bootpress/helpers";
 
 const app = express();
 app.use(express.json());
@@ -23,8 +23,8 @@ const UserServiceImpl = {
         return this.users;
     },
     findUserById(idInParams: string) {
-        const id = asInteger(idInParams);
-        return getOrThrow(this.users.find(user => user == id), new HttpError(404, "Not Found"));
+        const id = as(idInParams, "integer");
+        return getOrThrow(this.users.find(user => user === id), new HttpError(404, "Not Found"));
     }
 };
 
@@ -37,33 +37,34 @@ 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";
+import { as, asStrict, getOrThrow } from "bootpress/helpers";
 
 class PostServiceImpl {
     posts = [1, 2, 3, 4, 5];
-    findById(id: number | string) {
-        console.log("looking for " + id);
+    findById(id: string) {
         return getOrThrow(
-            this.posts.find(p => p == id),
+            this.posts.find(p => p === as(id, "integer")),
             new HttpError(404, "Post is not found")
         );
     }
     add(body: any) {
-        let casted = asSchema(body, {
+        let casted = asStrict(body, {
             "id": "number"
         });
         this.posts.push(casted.id);
         return new HttpResponse(201, casted.id);
     }
     delete(deleteInQuery: string, idInQuery: string) {
-        const idx = deleteInQuery === "yes" ? this.posts.indexOf(asInteger(idInQuery)) : -1;
+        const idx = deleteInQuery === "yes" ? this.posts.indexOf(as(idInQuery, "integer")) : -1;
         if (idx > -1) {
-            this.posts.splice(idx, 1);
-            this.#printDeleted(idInQuery);
+            this.#logDeleted(idInQuery);
+            return this.posts.splice(idx, 1);
+        }else {
+            throw new HttpError(404, "Post is not found")
         }
     }
     // use private methods to  
-    #printDeleted(id: number | string) {
+    #logDeleted(id: number | string) {
         console.warn(`post ${id} is deleted`)
     }
     findAll() {
@@ -126,4 +127,25 @@ class LogServiceImpl {
 const LogService = new LogServiceImpl();
 
 app.get("/logs", LogService.findAll() as RequestHandler)
-```
+```
+
+## v7.0.0 Release Notes:
+
+### Deprecated helper methods:
+- asSchema
+- asString
+- asBoolean
+- asInteger
+- asNumber
+
+Please use "as" or "asStrict" instead of these functions. For example:
+
+```ts
+//const x: string = asString(o); // deprecated
+const x: string = as(o, "string"); 
+```
+
+### Added / Changed helper methods:
+- asStrict : Asserts types strictly
+- PassBodyAs(schema): Body must be as same as schema
+- ParseBodyAs(schema): Body have to be parsable to schema

package/helpers/index.d.ts

@@ -7,6 +7,8 @@ type TypeMap = {
     "boolean[]": boolean[],
     "number": number,
     "number[]": number[],
+    "integer": number,
+    "integer[]": number[]
 }
 
 type ValidTypeKeys = keyof TypeMap;
@@ -29,12 +31,7 @@ type TypedSchema<T> = {
 }
 
 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 asString(o: any): string;
-export function asSchema<T extends JsSchema>(o: any, jsSchema: T): TypedSchema<T>;
+export function getOrElse<T, E>(data: T, defaultValue: E): E extends NonNullable<infer T> ? E : T | E;
 export function schema<T extends JsSchema>(schema: T): T;
 
 type ExtendedTypeMap = {
@@ -58,4 +55,5 @@ type ExtendedTypeMap = {
 
 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>;
+export function as<T extends (ExtendedTypeKeys | JsSchema | ArraySchema)>(o:any, type: T, errorVariableName?: string): T extends ExtendedTypeKeys ? ExtValOf<T> : TypedSchema<T>;
+export function asStrict<T extends (ExtendedTypeKeys | JsSchema | ArraySchema)>(o:any, type: T, errorVariableName?: string): T extends ExtendedTypeKeys ? ExtValOf<T> : TypedSchema<T>;

package/helpers/index.js

@@ -1,5 +1,7 @@
 const { HttpError } = require("../types");
 
+const allowedPrimitives = ["string", "number", "boolean", "integer"];
+
 function getOrThrow(data, error) {
     if (data === null || data === undefined) {
         throw error;
@@ -34,9 +36,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;
+    } else if (typeof o === "number") {
+        if (o === 1) return true;
+        if (o === 0) return false;
     }
     throw new HttpError(errorStatus, errorMessage);
 }
@@ -68,7 +70,7 @@ function asInteger(o, errorMessage = undefined, errorStatus = 400) {
 }
 
 function asString(o, errorMessage = undefined, errorStatus = 400) {
-    errorMessage = errorMessage ?? `Value ${o} should have been a string but it's not`;
+    errorMessage = errorMessage ?? `Value ${o} should have been a string but it's ${typeof o}`;
     const validTypes = ["string", "number"];
     if (validTypes.includes(typeof o)) {
         return '' + o;
@@ -77,7 +79,10 @@ function asString(o, errorMessage = undefined, errorStatus = 400) {
     }
 }
 
-function asSchema(o, schema) {
+function asSchema(o, schema, strict = false) {
+    if(!(schema instanceof Object) || Array.isArray(schema)){
+        throw new HttpError(500, `Schema is not valid ${JSON.stringify(schema)}`);
+    }
     const schemaKeyValues = Object.entries(schema);
     let result = {};
     for (let i = 0; i < schemaKeyValues.length; i++) {
@@ -90,33 +95,19 @@ function asSchema(o, schema) {
             }
         }
         const expectedType = schemaKeyValues[i][1];
-        const errorMessage = o[key] == null ? `Value of ${key} should have been a ${expectedType} but it's null` : `Value of ${key} should have been a ${expectedType} but it's a ${typeof o[key]}`;
 
         if (typeof expectedType === "object") {
             if (Array.isArray(expectedType)) {
                 result[key] = [];
                 for (let j = 0; j < o[key].length; j++) {
-                    result[key][j] = asSchema(o[key][j], expectedType[0])
+                    result[key][j] = asSchema(o[key][j], expectedType[0], strict)
                 }
             } else {
-                result[key] = asSchema(o[key], expectedType);
+                result[key] = asSchema(o[key], expectedType, strict);
             }
         }
         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) {
-                        throw new HttpError(400, `Each element of ${key} should have been a ${elementType} but a ${typeof o[key][j]} is present (${o[key][j]})`);
-                    }
-                }
-                result[key] = o[key];
-            }
-            else if (typeof o[key] === expectedType) {
-                result[key] = o[key];
-            } else {
-                throw new HttpError(400, errorMessage);
-            }
+            result[key] = strict ? asStrict(o[key], expectedType, key) : as(o[key], expectedType, key);
         }
         else {
             throw new HttpError(500, `Type of a schema key should be a primitive type or another schema`);
@@ -130,14 +121,10 @@ function schema(schema) {
     return schema;
 }
 
-function asArrayOf(o, elementType) {
+function asPrimitiveArrayOf(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]}`);
-            }
+            o[i] = checkPrimitive(o[i], elementType, "Array elemet");
         }
         return o;
     } else {
@@ -145,49 +132,50 @@ function asArrayOf(o, elementType) {
     }
 }
 
-function as(o, type) {
-    if (typeof type == "string") {
+function as(o, type, namedErrorVariable = o) {
+    if (typeof type === "string") {
         if (type.endsWith("[]")) {
             // array check
             const elementType = type.replace("[]", "");
-            return asArrayOf(o, elementType);
-        } else {
-            if(type.endsWith("?") && o == null){
+            return asPrimitiveArrayOf(o, elementType);
+        } else { // non array types:
+            if (type.endsWith("?") && o == null) {
                 return null;
-            }else if(type.endsWith("?") && o != null ){
+            } else if (type.endsWith("?") && o != null) {
                 const actualType = type.replace("?", "");
-                return as(o, actualType);
+                return as(o, actualType, namedErrorVariable);
             }
             // primitive check
             switch (type) {
                 case "string":
-                    return asString(o);
+                    return asString(o, `Type of ${namedErrorVariable} should have been a string but it's ${o == null ? "null" : typeof o}`);
                 case "number":
-                    return asNumber(o);
+                    return asNumber(o, `Type of ${namedErrorVariable} should have been a number but it's ${o == null ? "null" : typeof o}`);
                 case "boolean":
-                    return asBoolean(o);
+                    return asBoolean(o, `Type of ${namedErrorVariable} should have been a boolean but it's ${o == null ? "null" : typeof o}`);
                 case "integer":
-                    return asInteger(o);
+                    return asInteger(o, `Type of ${namedErrorVariable} should have been an integer but it's ${o == null ? "null" : typeof o}`);
                 default:
                     throw new HttpError(500, `Unsupported type ${type}`);
             }
         }
-    } else if (typeof type == "object" && type != null) {
+    } else if (typeof type === "object" && type != null) {
         if (Array.isArray(type)) {
-            if(type.length > 1){
+            if (type.length > 1) {
                 throw new HttpError(500, `You can define only one schema for types ArrayOf<Schema>`);
-            }else if (type.length < 1){
+            } 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)){
+            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);
+            let result = [];
+            for (let i = 0; i < o.length; i++) {
+                result.push(asSchema(o[i], providedSchema));
             }
-            return o;
+            return result;
         } else {
             // schema validation
             return asSchema(o, type);
@@ -197,14 +185,69 @@ function as(o, type) {
     }
 }
 
+function asStrict(o, type, namedErrorVariable = o) {
+    if (typeof type === "string") {
+        if (type.endsWith("[]")) {
+            // array check
+            const elementType = type.replace("[]", "");
+            return asPrimitiveArrayOf(o, elementType);
+        } else { // non array types:
+            if (type.endsWith("?") && o == null) {
+                return null;
+            } else if (type.endsWith("?") && o != null) {
+                const actualType = type.replace("?", "");
+                return asStrict(o, actualType, namedErrorVariable);
+            }
+            // primitive check
+            if (!allowedPrimitives.includes(type)) {
+                throw new HttpError(500, `Unsupported type ${type}`);
+            }
+            return checkPrimitive(o, type, namedErrorVariable);
+        }
+    } 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 but it's ${typeof o}`)
+            }
+            const providedSchema = type[0];
+            let result = [];
+            for (let i = 0; i < o.length; i++) {
+                result.push(asSchema(o[i], providedSchema, true));
+            }
+            return result;
+        } else {
+            // schema validation
+            return asSchema(o, type, true);
+        }
+    } else {
+        throw new HttpError(500, `Unsupported type check ${type}`)
+    }
+}
+
+function checkPrimitive(o, type, varName = o) {
+    const error = new HttpError(400, `${varName} should have been a ${type}. But it's ${typeof o}`);
+    if (type === "integer") {
+        if (!Number.isInteger(o)) {
+            throw error;
+        }
+        return o;
+    }
+    if (typeof o !== type) {
+        throw error;
+    }
+    return o;
+}
+
 module.exports = {
     getOrThrow,
     getOrElse,
-    asBoolean,
-    asNumber,
-    asInteger,
-    asString,
-    asSchema,
     schema,
-    as
+    as,
+    asStrict
 }

package/index.d.ts

@@ -16,6 +16,7 @@ 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 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
@@ -38,6 +39,7 @@ export {
     PassAllCookies,
     PassBody,
     PassBodyAs,
+    ParseBodyAs,
     PassRequest,
     PassResponse
 }

package/index.js

@@ -1,4 +1,4 @@
-const { as } = require("./helpers");
+const { as, asStrict } = require("./helpers");
 const { HttpError } = require("./types");
 
 const protectedProperties = [
@@ -155,13 +155,26 @@ function PassAllQueries(actualHandler) {
     }
 }
 
-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 ParseBodyAs(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)
+                    }
+                }
+            }
         }
     }
 }
@@ -172,16 +185,16 @@ function PassBodyAs(type) {
             if (isRequstHandlerArgs(args)) {
                 const req = args.at(-3); const res = args.at(-2);
                 try {
-                    return actualHandler(as(req.body, type))(req, res);
+                    return actualHandler(asStrict(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){
+                    try {
+                        return actualHandler(...args, asStrict(req.body, type))(req, res);
+                    } catch (e) {
                         reply(res, e.status || 500, e.message || e)
                     }
                 }
@@ -190,6 +203,28 @@ function PassBodyAs(type) {
     }
 }
 
+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) {
+                    reply(res, e.status || 500, e.message || e);
+                }
+
+            } else {
+                return (req, res) => {
+                    try {
+                        return actualHandler(...args, req.body)(req, res);
+                    } catch (e) {
+                        reply(res, e.status || 500, e.message || e)
+                    }
+                }
+            }
+        }
+}
+
 function PassRequest(actualHandler) {
     return (...args) => {
         if (isRequstHandlerArgs(args)) {
@@ -249,6 +284,7 @@ module.exports = {
     PassCookies,
     PassBody,
     PassBodyAs,
+    ParseBodyAs,
     PassRequest,
     PassResponse
 }

package/package.json

@@ -1,33 +1,33 @@
-{
-  "name": "bootpress",
-  "version": "6.0.1",
-  "description": "REST service methods for express",
-  "main": "index.js",
-  "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",
-  "dependencies": {
-    "express": "^4.18.2"
-  },
-  "devDependencies": {
-    "@types/express": "^4.17.17",
-    "typescript": "^4.9.5"
-  }
-}
+{
+  "name": "bootpress",
+  "version": "7.0.0",
+  "description": "REST service methods for express",
+  "main": "index.js",
+  "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",
+  "dependencies": {
+    "express": "^4.18.2"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.17",
+    "typescript": "^4.9.5"
+  }
+}