barehttp 0.4.2 → 0.6.0

package/README.md

@@ -51,23 +51,23 @@ import { BareHttp, logMe } from 'barehttp';
 
 const app = new BareHttp();
 
-app.get({
+app.route.get({
   route: '/route',
   handler: function routeGet(flow) {
-    flow.json({ everythings: 'OK' });
+    flow.json({ everything: 'OK' });
   })
 });
 
 
 // you can chain the routes
-app
+app.route
   .post({
     route: '/route',
     handler: async function routePost(flow) {
       return 'RESPONSE POST';
     },
   })
-  .patch({
+  .route.patch({
     route: '/route',
     handler: async function routePatch(flow) {
       return 'RESPONSE PATCH';
@@ -90,7 +90,7 @@ import { BareHttp, logMe } from 'barehttp';
 
 const app = new BareHttp({ logging: true });
 
-app.get({
+ app.route.get({
   route:'/route',
   handler: async function routeV1() {
     return { promised: 'data' };
@@ -195,7 +195,7 @@ The order of the middlewares is followed by code declarations order.
 
 ---
 
-## `BareServer.get | post | patch | put | delete | options | head | declare` (Function)
+## `BareServer.route.get | post | patch | put | delete | options | head | declare` (Function)
 
 To set a route for `get | post | patch | put | delete | options | head` with following parameters:
 
@@ -206,7 +206,7 @@ To set a route for `get | post | patch | put | delete | options | head` with fol
   Example
 
 ```ts
-app.get({
+app.route.get({
   route: '/route',
   options: { timeout: 2000 },
   handler: async (flow) => {
@@ -214,7 +214,7 @@ app.get({
   },
 });
 
-app.declare({
+app.route.declare({
   route: '/declared_route',
   handler: () => {
     return 'My declared route response';
@@ -399,17 +399,42 @@ Some of the features are in progress.
 - [x] Request execution cancellation by timeout
 - [x] Bulk/chaining routes declaration
 - [x] Runtime routes hot swapping
+- [x] runtime validation schema generation per route response types (on project compile/on launch)
 - [ ] middlewares per route
 - [ ] swagger OpenAPI 3.0 on `/docs` endpoint
 - [ ] swagger OpenAPI 3.0 scheme on `/docs_raw` endpoint
 - [ ] optional export of generated schema to a location (yaml, json)
 - [ ] streaming/receiving of chunked multipart
-- [ ] runtime validation schema generation per route response types (on project compile/on launch)
 - [ ] runtime route params or query validation upon declared types (on project compile/on launch)
 
+## Runtime schema validation on response (EXPERIMENTAL)
+
+This feature enables a runtime check for the returned value for a route,
+for now it only works for `return` statements of the routes declared in handlers.
+
+Please write your `return` statements with plain response objects within the `handler` or `controller` function.
+
+To enable this feature you need to set up the following:
+
+- On `BareHttp` settings set: `enableSchemaValidation: true`
+- On `BareHttp` settings set: `declaredRoutesPaths: [...array of paths to routes]`,
+- On `route.<method>` declaration set: `options: { builtInRuntime: { output: true } }`
+
 ## Benchmarks
 
-(coming soon)
+Done on MacBook Pro with M1 Pro processor. No logs enabled. `NODE_ENV=production` is set. All settings set to default.
+
+### BareHttp
+
+![BareHttp](./docs/barehttp.png)
+
+### Express
+
+![Express](./docs/express.png)
+
+### Fastify
+
+![Fastify](./docs/fastify.png)
 
 ## Support
 

package/lib/logger/index.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -30,7 +34,7 @@ const pinoCommonOptions = {
         level: (label) => ({ level: label }),
     },
     messageKey: 'message',
-    prettyPrint: !env_1.envs.isProd,
+    transport: env_1.envs.isProd ? undefined : { target: 'pino-pretty', options: { colorize: true } },
 };
 const logger = (0, pino_1.default)(pinoCommonOptions, asyncDest[0]);
 const logHttp = (...params) => {

package/lib/request.d.ts

@@ -14,15 +14,17 @@ export declare type CacheOpts = {
     expirationSeconds?: number;
     revalidation?: Revalidation;
 };
-export declare class BareRequest {
+export declare class BareRequest<H extends {
+    [key: string]: string | undefined;
+} = {
+    [key: string]: string | undefined;
+}> {
     _originalRequest: IncomingMessage;
     _originalResponse: ServerResponse;
     ID: {
         code: string;
     };
-    params: {
-        [k: string]: string | undefined;
-    };
+    params: H;
     query: {
         [k: string]: string | undefined;
     };
@@ -38,6 +40,7 @@ export declare class BareRequest {
     private startTime?;
     private startDate;
     private remoteClient;
+    private logging;
     private requestTimeFormat?;
     private headers;
     private cookies;
@@ -76,6 +79,7 @@ export declare class BareRequest {
     stream<T extends NodeJS.WritableStream>(stream: T): void;
     json(data: any): void;
     _send(chunk?: string | ArrayBuffer | NodeJS.ArrayBufferView | SharedArrayBuffer): void;
+    sendStringifiedJson(data: string): void;
     send(anything?: any): void;
 }
 export {};

package/lib/request.js

@@ -21,7 +21,7 @@ class BareRequest {
     _originalRequest;
     _originalResponse;
     ID;
-    params = {};
+    params;
     query = {};
     remoteIp;
     requestBody;
@@ -33,6 +33,7 @@ class BareRequest {
     startTime;
     startDate = new Date();
     remoteClient = '';
+    logging = false;
     requestTimeFormat;
     headers = {};
     cookies = {};
@@ -41,10 +42,12 @@ class BareRequest {
     constructor(_originalRequest, _originalResponse, options) {
         this._originalRequest = _originalRequest;
         this._originalResponse = _originalResponse;
+        this.params = {};
         this.ID = { code: _originalRequest.headers['x-request-id'] || generateId() };
         this.remoteIp = _originalRequest.socket.remoteAddress;
         this.contentType = this._originalRequest.headers['content-type'];
         this.requestHeaders = this._originalRequest.headers;
+        this.logging = options?.logging ?? false;
         // this is a placeholder URL base that we need to make class working
         new url_1.default.URL(`http://localhost/${this._originalRequest.url}`).searchParams.forEach((value, name) => (this.query[name] = value));
         // parsed;
@@ -57,26 +60,28 @@ class BareRequest {
             this.startTime = process.hrtime();
             this.requestTimeFormat = options.requestTimeFormat;
         }
-        // call logging section
-        if (options?.logging === true) {
-            _originalResponse.on('close', () => (0, logger_1.logHttp)(this.headers, this.startDate, this.remoteClient, _originalRequest, _originalResponse));
-        }
     }
     readBody() {
-        if (['POST', 'PATCH', 'PUT'].includes(this._originalRequest.method))
-            return new Promise((resolve, reject) => {
-                const temp = [];
-                this._originalRequest
-                    .on('data', (chunk) => temp.push(chunk))
-                    .on('end', () => {
-                    const parsed = this.classifyRequestBody(temp);
-                    if (util_1.types.isNativeError(parsed))
-                        reject(parsed);
-                    this.requestBody = parsed;
-                    resolve();
-                })
-                    .on('error', reject);
-            });
+        switch (this._originalRequest.method) {
+            case 'POST':
+            case 'PATCH':
+            case 'PUT':
+                return new Promise((resolve, reject) => {
+                    const temp = [];
+                    this._originalRequest
+                        .on('data', (chunk) => temp.push(chunk))
+                        .on('end', () => {
+                        const parsed = this.classifyRequestBody(temp);
+                        if (util_1.types.isNativeError(parsed))
+                            return reject(parsed);
+                        this.requestBody = parsed;
+                        resolve(parsed);
+                    })
+                        .on('error', reject);
+                });
+            default:
+                return;
+        }
     }
     attachCookieManager(opts) {
         this.cm = new cookie_manager_1.CookiesManager(opts, this);
@@ -108,8 +113,6 @@ class BareRequest {
         this.remoteClient = remoteClient;
     }
     setRequestTime() {
-        if (!this.requestTimeFormat)
-            return;
         const diff = process.hrtime(this.startTime);
         const time = diff[0] * (this.requestTimeFormat === 's' ? 1 : 1e3) +
             diff[1] * (this.requestTimeFormat === 's' ? 1e-9 : 1e-6);
@@ -207,14 +210,6 @@ class BareRequest {
             logger_1.logMe.error('Trying to send with the headers already sent');
             return;
         }
-        this.sent = true;
-        let toSend = chunk;
-        switch (chunk?.constructor) {
-            case Uint16Array:
-            case Uint8Array:
-            case Uint32Array:
-                toSend = Buffer.from(chunk.buffer);
-        }
         // work basic headers
         if (typeof chunk !== 'undefined' && chunk !== null)
             this.setHeader('Content-Length', Buffer.byteLength(chunk, 'utf-8'));
@@ -222,10 +217,20 @@ class BareRequest {
             this.setHeaders({ 'Cache-Control': 'no-store', Expire: 0, Pragma: 'no-cache' });
         if (this.statusToSend >= 400 && this.statusToSend !== 404 && this.statusToSend !== 410)
             this.cleanHeader('Cache-Control');
-        this.setRequestTime();
+        if (this.requestTimeFormat)
+            this.setRequestTime();
         // perform sending
-        this._originalResponse.writeHead(this.statusToSend, statusTuples[this.statusToSend], this.headers);
-        this._originalResponse.end(toSend);
+        this._originalResponse.writeHead(this.statusToSend, '', this.headers);
+        this._originalResponse.end(chunk || statusTuples[this.statusToSend]);
+        this.sent = true;
+        // call logging section
+        if (this.logging === true) {
+            (0, logger_1.logHttp)(this.headers, this.startDate, this.remoteClient, this._originalRequest, this._originalResponse);
+        }
+    }
+    sendStringifiedJson(data) {
+        this.setHeader('Content-Type', 'application/json');
+        this._send(data);
     }
     send(anything) {
         if (this.sent)
@@ -236,6 +241,8 @@ class BareRequest {
             case Uint8Array:
             case Uint16Array:
             case Uint32Array:
+                this._send(Buffer.from(anything.buffer));
+                break;
             case Buffer:
             case String:
                 this._send(anything);
@@ -243,10 +250,12 @@ class BareRequest {
             case Boolean:
             case Number:
                 this._send('' + anything);
+                break;
             case stream_1.Writable:
                 this.stream(anything);
                 break;
             case Object:
+            case Array:
                 this.json(anything);
                 break;
             default:

package/lib/schemas/custom-schema.d.ts

@@ -0,0 +1,32 @@
+import { ts, Type } from 'ts-morph';
+export declare type StringSchemaType = {
+    type: 'string';
+    nullable: boolean;
+};
+export declare type NumberSchemaType = {
+    type: 'number';
+    nullable: boolean;
+};
+export declare type BooleanSchemaType = {
+    type: 'boolean';
+    nullable: boolean;
+};
+export declare type ArraySchemaType = {
+    type: 'array';
+    items: StringSchemaType | NumberSchemaType | BooleanSchemaType | ArraySchemaType | ObjectSchemaType;
+    nullable: boolean;
+};
+export declare type ObjectSchemaType = {
+    type: 'object';
+    properties: {
+        [key: string]: StringSchemaType | NumberSchemaType | BooleanSchemaType | ArraySchemaType | ObjectSchemaType;
+    };
+    nullable: boolean;
+};
+export declare type UnionSchemaType = {
+    type: 'union';
+    anyOf: CustomSchema[];
+    nullable: boolean;
+};
+export declare type CustomSchema = StringSchemaType | NumberSchemaType | BooleanSchemaType | ArraySchemaType | ObjectSchemaType | UnionSchemaType;
+export declare const generateCustomSchema: (t: Type<ts.Type>) => CustomSchema;

package/lib/schemas/custom-schema.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCustomSchema = void 0;
+const find_1 = __importDefault(require("lodash/find"));
+const helpers_1 = require("./helpers");
+const generateCustomSchema = (t) => {
+    if ((0, helpers_1.isFinalType)(t)) {
+        return { type: (0, helpers_1.getTypeGenericText)(t), nullable: false };
+    }
+    if (t.isUnion()) {
+        const nulled = t.getUnionTypes().some((nt) => (0, helpers_1.isNullType)(nt));
+        const cleanTypes = helpers_1.helpers.cleanNullableTypes(t.getUnionTypes());
+        let returning = {
+            nullable: false,
+            type: 'union',
+        };
+        const transformed = cleanTypes.reduce((acc, ut) => {
+            const regenerated = (0, exports.generateCustomSchema)(ut);
+            if ((0, find_1.default)(acc, regenerated))
+                return acc;
+            return acc.concat(regenerated);
+        }, []);
+        if (transformed.length > 1) {
+            returning.anyOf = transformed;
+        }
+        else {
+            returning = transformed[0];
+        }
+        if (nulled) {
+            returning.nullable = true;
+        }
+        return returning;
+    }
+    if (t.isIntersection()) {
+        return t.getIntersectionTypes().reduce((acc, it) => {
+            const generatedSchema = (0, exports.generateCustomSchema)(it);
+            if (Object.keys(acc).length === 0) {
+                acc = generatedSchema;
+                return acc;
+            }
+            if (generatedSchema.type === acc.type && acc.type === 'object') {
+                acc.properties = { ...acc.properties, ...generatedSchema.properties };
+            }
+            return acc;
+        }, {});
+    }
+    if (t.isArray()) {
+        return {
+            type: 'array',
+            items: (0, exports.generateCustomSchema)(t.getArrayElementType()),
+        };
+    }
+    if (t.isInterface() || t.isObject()) {
+        const result = t.getProperties().reduce((acc, ci) => {
+            const val = ci.getValueDeclaration();
+            acc.properties = { ...acc.properties, [ci.getName()]: (0, exports.generateCustomSchema)(val.getType()) };
+            return acc;
+        }, { type: 'object', properties: {} });
+        return result;
+    }
+    return {
+        type: (0, helpers_1.getApparentTypeName)(t),
+        nullable: false,
+    };
+};
+exports.generateCustomSchema = generateCustomSchema;

package/lib/schemas/dirty-tsm.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/schemas/dirty-tsm.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ts_morph_1 = require("ts-morph");
+const custom_schema_1 = require("./custom-schema");
+const helpers_1 = require("./helpers");
+const project = new ts_morph_1.Project({ tsConfigFilePath: 'tsconfig.json' });
+project.enableLogging();
+const sourceFile = project.getSourceFile('server.ts');
+const tp = sourceFile?.getClass('BareServer')?.getMember('route');
+const isHandler = (c) => c.getSymbol()?.getName() === 'handler';
+const isRoute = (c) => c.getSymbol()?.getName() === 'route';
+function returnFinder(route, base) {
+    if (!base) {
+        throw new Error('No project been allocated, theres some issue');
+    }
+    const refsAcrossProject = base
+        .getChildrenOfKind(ts_morph_1.ts.SyntaxKind.Identifier)[0]
+        .findReferences()[0]
+        .getReferences()
+        ?.filter((re) => re.compilerObject.fileName.includes(route));
+    if (!refsAcrossProject?.length) {
+        console.log('There are no routes declarations across the project');
+        process.exit(0);
+    }
+    const extractedReturns = refsAcrossProject.map((ref) => {
+        return ref
+            .getNode()
+            .getAncestors()
+            .find((n) => n.getKind() === ts_morph_1.ts.SyntaxKind.CallExpression)
+            ?.getChildren()
+            .find((n) => n.getKind() === ts_morph_1.ts.SyntaxKind.SyntaxList)
+            ?.getFirstChild()
+            ?.getChildSyntaxList()
+            ?.getChildren()
+            .filter((c) => {
+            return c.getKind() === ts_morph_1.ts.SyntaxKind.PropertyAssignment && (isHandler(c) || isRoute(c));
+        })
+            .map((c) => {
+            if (isHandler(c)) {
+                return {
+                    type: 'handler',
+                    syntaxList: c
+                        .getChildren()
+                        .find((n) => n.getKind() === ts_morph_1.ts.SyntaxKind.ArrowFunction ||
+                        n.getKind() === ts_morph_1.ts.SyntaxKind.FunctionExpression)
+                        ?.getLastChild()
+                        ?.getChildSyntaxList(),
+                };
+            }
+            return {
+                type: 'route',
+                value: c
+                    .getNodeProperty('initializer')
+                    .getText()
+                    ?.replaceAll("'", ''),
+            };
+        });
+    });
+    const perRoute = extractedReturns
+        .map((routeCombination) => {
+        return routeCombination.reduce((acc, curr) => {
+            if (curr.type === 'handler') {
+                return {
+                    ...acc,
+                    handler: curr.syntaxList,
+                };
+            }
+            else {
+                return {
+                    ...acc,
+                    route: curr.value,
+                };
+            }
+        }, {});
+    })
+        .map((routeCombination) => ({
+        ...routeCombination,
+        handler: getReturnStatements(routeCombination.handler),
+    }));
+    const schemas = perRoute.map(({ handler, route }) => {
+        const schemas = handler.map((t) => (0, custom_schema_1.generateCustomSchema)(t));
+        let finalSchema = schemas[0];
+        if (schemas.length > 1) {
+            finalSchema = {
+                type: 'union',
+                nullable: false,
+                anyOf: schemas,
+            };
+        }
+        return {
+            route,
+            schemas,
+            finalSchema,
+        };
+    });
+    return schemas;
+}
+// const res = tp
+//   ?.getChildrenOfKind(ts.SyntaxKind.Identifier)[0]
+//   .findReferences()[0]
+//   .getReferences()
+//   .filter((ref) => !ref.compilerObject.fileName.includes('server.ts'))[0]
+//   .getNode()
+//   .getAncestors()
+//   .filter((n) => n.getKind() === ts.SyntaxKind.CallExpression)[0]
+//   .getAncestors()[0]
+//   .getChildrenOfKind(ts.SyntaxKind.CallExpression)[0]
+//   .getChildrenOfKind(ts.SyntaxKind.SyntaxList)[0]
+//   .getChildren()[0]
+//   .getChildrenOfKind(ts.SyntaxKind.SyntaxList)[0]
+//   .getChildrenOfKind(ts.SyntaxKind.PropertyAssignment)
+//   .find((node) =>
+//     node
+//       .getChildren()
+//       .find(
+//         (n) =>
+//           n.getKind() === ts.SyntaxKind.ArrowFunction ||
+//           n.getKind() === ts.SyntaxKind.FunctionExpression,
+//       ),
+//   )
+//   ?.getChildren()
+//   ?.find((c) => c.getKind() === ts.SyntaxKind.FunctionExpression)
+//   ?.getLastChild()
+//   ?.getChildSyntaxList()
+//   ?.getChildren()
+//   .filter((c) => c.getKind() === ts.SyntaxKind.IfStatement)[0]
+//   .getChildren()
+//   .find((c) => c.getKind() === ts.SyntaxKind.Block)
+//   ?.getChildSyntaxList();
+const extractReturnStatements = (accumulator, n) => {
+    if (!n)
+        return;
+    if (ts_morph_1.ts.SyntaxKind.IfStatement === n.getKind()) {
+        const thenProp = n.getNodeProperty('thenStatement');
+        const elseProp = n.getNodeProperty('elseStatement');
+        const thenSyntax = thenProp?.getChildSyntaxList();
+        const elseSyntax = elseProp?.getChildSyntaxList();
+        extractReturnStatements(accumulator, thenSyntax);
+        extractReturnStatements(accumulator, elseSyntax);
+        return;
+    }
+    if (n.getChildren().length) {
+        const cleanChildren = n.getChildren().filter((c) => typeof c.getKind === 'function');
+        const findReturn = cleanChildren.find((c) => c.getKind() === ts_morph_1.ts.SyntaxKind.ReturnStatement);
+        const thereIf = cleanChildren.find((c) => c.getKind() === ts_morph_1.ts.SyntaxKind.IfStatement);
+        const thereWhile = cleanChildren.find((c) => c.getKind() === ts_morph_1.ts.SyntaxKind.WhileKeyword);
+        const thereFor = cleanChildren.find((c) => c.getKind() === ts_morph_1.ts.SyntaxKind.ForStatement);
+        const syntaxList = n.getChildSyntaxList();
+        if (findReturn) {
+            accumulator.push(findReturn);
+        }
+        extractReturnStatements(accumulator, thereIf);
+        extractReturnStatements(accumulator, thereWhile);
+        extractReturnStatements(accumulator, thereFor);
+        extractReturnStatements(accumulator, syntaxList);
+    }
+};
+const getReturnStatements = (n) => {
+    if (!n)
+        return [];
+    const accumulator = [];
+    extractReturnStatements(accumulator, n);
+    return accumulator
+        .map((r) => r.getChildren().find((c) => {
+        const type = c.getType();
+        return type.isObject() || (0, helpers_1.isFinalType)(type);
+    }))
+        .filter((n) => n)
+        .map((acc) => acc.getType());
+    // console.log({ accumulator });
+    // let baseChildren = n?.getChildren()?.filter((c) => typeof c.getKind === 'function') ?? [];
+    // baseChildren = baseChildren.flat(5).filter((c) => typeof c.getKind === 'function');
+    // if (thereIf || thereBlock || thereWhile || thereFor) {
+    //   baseChildren?.push(
+    //     getReturnStatements(thereIf) as any,
+    //     getReturnStatements(thereWhile) as any,
+    //     getReturnStatements(thereBlock) as any,
+    //     getReturnStatements(thereFor) as any,
+    //   );
+    // }
+    // baseChildren = baseChildren.flat(5).filter((c) => typeof c.getKind === 'function');
+    // return baseChildren
+    //   .filter((c) => typeof c.getKind === 'function')
+    //   .filter((c) => c.getKind() === ts.SyntaxKind.ReturnStatement)
+    //   .map((r) =>
+    //     r.getChildren().find((c) => {
+    //       const type = c.getType();
+    //       return type.isObject() || isFinalType(type);
+    //     }),
+    //   )
+    //   .filter((v) => v)
+    //   .map((v) => v!.getType());
+};
+// returnFinder('examples', tp);
+(0, helpers_1.logInternals)(returnFinder('examples', tp));
+// logInternals(returnFinder('examples', tp).map((s) => convertToJsonSchema(s)));
+// console.log(tp);
+// logInternals(getReturnStatements(res!)?.map((t) => regenerateTypeSchema(t!)));
+// regenerateTypeSchema(res![0].getType());
+// logInternals(regenerateTypeSchema(res![0].getType()));
+// console.log(regenerateTypeSchema(res![0].getType()));

package/lib/schemas/generator.d.ts

@@ -0,0 +1,7 @@
+export declare const generateRouteSchema: (fileRouteToDeclarations: string) => {
+    route: string;
+    methodName: "get" | "post" | "put" | "delete" | "patch" | "options" | "head";
+    schemas: import("./custom-schema").CustomSchema[];
+    finalSchema: import("./custom-schema").CustomSchema;
+    jsonSchema: any;
+}[];