barehttp 0.4.2 → 0.6.0

package/lib/schemas/generator.js

@@ -0,0 +1,186 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRouteSchema = void 0;
+const ts_morph_1 = require("ts-morph");
+const custom_schema_1 = require("./custom-schema");
+const helpers_1 = require("./helpers");
+const json_schema_1 = require("./json-schema");
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("fs");
+const project = new ts_morph_1.Project({ tsConfigFilePath: path_1.default.join(process.cwd(), '/tsconfig.json') });
+const nodeModulesFile = path_1.default.join(process.cwd(), 'node_modules', 'barehttp');
+const isInstalledPackage = (0, fs_1.existsSync)(nodeModulesFile);
+if (isInstalledPackage)
+    project.addSourceFileAtPath(nodeModulesFile + '/lib/server.d.ts');
+const serverSourceFile = project.getSourceFile('server.d.ts');
+const routes = serverSourceFile?.getClass('BareServer')?.getMember('route');
+const runtimeRoutes = serverSourceFile?.getClass('BareServer')?.getMember('runtimeRoute');
+// const requestSourceFile = project.getSourceFile('request.ts');
+// const flowJson = requestSourceFile?.getClass('BareRequest')?.getMember('json');
+// const flowSend = requestSourceFile?.getClass('BareRequest')?.getMember('send');
+const acceptedPropertyNames = ['get', 'post', 'put', 'delete', 'options', 'head', 'patch'];
+const getReferences = (fileRoute, target) => {
+    if (!target)
+        return [];
+    return target
+        ?.getChildrenOfKind(ts_morph_1.ts.SyntaxKind.Identifier)[0]
+        .findReferences()[0]
+        .getReferences()
+        ?.filter((re) => {
+        return re.compilerObject.fileName.includes(fileRoute);
+    });
+};
+// needed for future (extract call functions)
+// const getFlowNodes = (n?: ClassMemberTypes) => {
+//   if (!n) return [];
+//   return n
+//     .getChildrenOfKind(ts.SyntaxKind.Identifier)[0]
+//     .findReferences()[0]
+//     .getReferences()
+//     .map((r) => r.getNode().getParent()?.getParent())
+//     .filter((p) => p?.getKind() === ts.SyntaxKind.CallExpression)
+//     .map((p) => p?.getNodeProperty('arguments' as any));
+// };
+const generateRouteSchema = (fileRouteToDeclarations) => {
+    if (!routes && !runtimeRoutes) {
+        throw new Error('No project been allocated, theres some issue');
+    }
+    const allReferences = [
+        ...getReferences(fileRouteToDeclarations, routes),
+        ...getReferences(fileRouteToDeclarations, runtimeRoutes),
+    ];
+    const extractedReturns = allReferences.map((ref) => {
+        const methodName = ref
+            .getNode()
+            .getAncestors()
+            .map((n) => n.getSymbol()?.getName())
+            .filter((param) => acceptedPropertyNames.includes(param))
+            .pop();
+        if (!methodName) {
+            return [];
+        }
+        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 && ((0, helpers_1.isHandler)(c) || (0, helpers_1.isRoute)(c));
+        })
+            .map((c) => {
+            if ((0, helpers_1.isHandler)(c)) {
+                return {
+                    type: 'handler',
+                    methodName,
+                    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',
+                methodName,
+                value: c
+                    .getNodeProperty('initializer')
+                    .getText()
+                    ?.replaceAll("'", ''),
+            };
+        });
+    });
+    const perRoute = extractedReturns
+        .map((routeCombination) => {
+        return routeCombination.reduce((acc, curr) => {
+            acc.methodName = curr.methodName;
+            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
+        .filter((pr) => pr.route && pr.handler.length)
+        .map(({ handler, route, methodName }) => {
+        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,
+            methodName,
+            schemas,
+            finalSchema,
+            jsonSchema: (0, json_schema_1.convertToJsonSchema)(finalSchema),
+        };
+    });
+    return [...schemas];
+};
+exports.generateRouteSchema = generateRouteSchema;
+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 getTypes = (nodes) => nodes
+    .map((r) => r.getChildren().find((c) => {
+    const type = c.getType();
+    return type.isObject() || (0, helpers_1.isFinalType)(type);
+}))
+    .filter((n) => n && typeof n.getType === 'function')
+    .map((acc) => acc.getType());
+const getReturnStatements = (n) => {
+    if (!n)
+        return [];
+    const accumulator = [];
+    extractReturnStatements(accumulator, n);
+    return getTypes(accumulator);
+};

package/lib/schemas/helpers.d.ts

@@ -0,0 +1,27 @@
+import { Node, PropertyAssignment, ts, Type } from 'ts-morph';
+export declare const helpers: {
+    findCallExpressionFromChildren: (property: PropertyAssignment) => Node<ts.Node>[];
+    findCallExpression: (n: Node<ts.Node>[]) => Node<ts.Node> | undefined;
+    findSyntaxList: (property: PropertyAssignment | Node<ts.Node>) => Node<ts.Node> | undefined;
+    findFunction: (property: PropertyAssignment) => Node<ts.Node> | undefined;
+    findReturnStatement: (property: PropertyAssignment) => Node<ts.Node> | undefined;
+    findIdentifier: (property: PropertyAssignment) => Node<ts.Node> | undefined;
+    findObjectLiteralExpressionFromChildren: (property: PropertyAssignment) => Node<ts.Node> | undefined;
+    findObjectLiteralExpression: (n: Node<ts.Node>[]) => Node<ts.Node> | undefined;
+    filterPropertyAssignmentFromChildren: (property: PropertyAssignment) => Node<ts.Node>[];
+    findPropertyAssignmentFromChildren: (property: PropertyAssignment) => Node<ts.Node> | undefined;
+    findPropertyAssignment: (n: Node<ts.Node>[]) => Node<ts.Node> | undefined;
+    findUnionTypeNodeFromChildren: (n: Node<ts.Node>) => Node<ts.Node> | undefined;
+    findNullableTypeFromChildren: (n: Node<ts.Node>) => Node<ts.Node> | undefined;
+    filterNullableTypeFromChildren: (n: Node<ts.Node>) => Node<ts.Node>[];
+    cleanNullableTypes: (t: Type<ts.Type>[]) => Type<ts.Type>[];
+};
+export declare const isFinalType: (t: Type<ts.Type>) => boolean;
+export declare const isNullType: (t: Type<ts.Type>) => boolean;
+declare type ResolvedBasicTypes = 'string' | 'number' | 'boolean' | 'array' | 'object';
+export declare const isHandler: (c: Node<ts.Node>) => boolean;
+export declare const isRoute: (c: Node<ts.Node>) => boolean;
+export declare const getTypeGenericText: (t: Type<ts.Type>) => ResolvedBasicTypes;
+export declare const getApparentTypeName: (t: Type<ts.Type>) => string;
+export declare function logInternals(data: any): void;
+export {};

package/lib/schemas/helpers.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logInternals = exports.getApparentTypeName = exports.getTypeGenericText = exports.isRoute = exports.isHandler = exports.isNullType = exports.isFinalType = exports.helpers = void 0;
+const ts_morph_1 = require("ts-morph");
+const util_1 = require("util");
+exports.helpers = {
+    findCallExpressionFromChildren: (property) => property.getChildren(),
+    findCallExpression: (n) => n.find((x) => x.getKind() === ts_morph_1.ts.SyntaxKind.CallExpression),
+    findSyntaxList: (property) => property.getChildren().find((x) => x.getKind() === ts_morph_1.ts.SyntaxKind.SyntaxList),
+    findFunction: (property) => property
+        .getChildren()
+        .find((x) => x.getKind() === ts_morph_1.ts.SyntaxKind.ArrowFunction ||
+        x.getKind() === ts_morph_1.ts.SyntaxKind.FunctionExpression),
+    findReturnStatement: (property) => property.getChildren().find((x) => x.getKind() === ts_morph_1.ts.SyntaxKind.ReturnStatement),
+    findIdentifier: (property) => property.getChildren().find((x) => x.getKind() === ts_morph_1.ts.SyntaxKind.ReturnStatement),
+    findObjectLiteralExpressionFromChildren: (property) => property.getChildren().find((x) => x.getKind() === ts_morph_1.ts.SyntaxKind.ObjectLiteralExpression),
+    findObjectLiteralExpression: (n) => n.find((x) => x.getKind() === ts_morph_1.ts.SyntaxKind.ObjectLiteralExpression),
+    filterPropertyAssignmentFromChildren: (property) => property.getChildren().filter((x) => x.getKind() === ts_morph_1.ts.SyntaxKind.PropertyAssignment),
+    findPropertyAssignmentFromChildren: (property) => property.getChildren().find((x) => x.getKind() === ts_morph_1.ts.SyntaxKind.PropertyAssignment),
+    findPropertyAssignment: (n) => n.find((x) => x.getKind() === ts_morph_1.ts.SyntaxKind.PropertyAssignment),
+    findUnionTypeNodeFromChildren: (n) => n.getChildren().find((x) => x.getKind() === ts_morph_1.ts.SyntaxKind.UnionType),
+    findNullableTypeFromChildren: (n) => n.getChildren().find((x) => (0, exports.isNullType)(x.getType())),
+    filterNullableTypeFromChildren: (n) => n.getChildren().filter((x) => !(0, exports.isNullType)(x.getType())),
+    cleanNullableTypes: (t) => t.filter((x) => !(0, exports.isNullType)(x)),
+}; //Prop
+const isFinalType = (t) => t.isNumber() || t.isString() || t.isBoolean() || t.isLiteral();
+exports.isFinalType = isFinalType;
+const isNullType = (t) => t.isNull() || t.isUndefined();
+exports.isNullType = isNullType;
+const isHandler = (c) => c.getSymbol()?.getName() === 'handler';
+exports.isHandler = isHandler;
+const isRoute = (c) => c.getSymbol()?.getName() === 'route';
+exports.isRoute = isRoute;
+const getTypeGenericText = (t) => {
+    if (t.isStringLiteral() || t.isNumberLiteral() || t.isBooleanLiteral()) {
+        return t.getBaseTypeOfLiteralType().getText();
+    }
+    else {
+        return t.getText();
+    }
+};
+exports.getTypeGenericText = getTypeGenericText;
+const getApparentTypeName = (t) => {
+    return t.getApparentType().getText().toLowerCase();
+};
+exports.getApparentTypeName = getApparentTypeName;
+function logInternals(data) {
+    console.log((0, util_1.inspect)(data, false, null, true));
+}
+exports.logInternals = logInternals;

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

@@ -0,0 +1,2 @@
+import { CustomSchema } from './custom-schema';
+export declare const convertToJsonSchema: (schema: CustomSchema) => any;

package/lib/schemas/json-schema.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToJsonSchema = void 0;
+const convertToJsonSchema = (schema) => {
+    if (schema.type === 'string') {
+        return {
+            type: 'string',
+        };
+    }
+    if (schema.type === 'number') {
+        return {
+            type: 'number',
+        };
+    }
+    if (schema.type === 'boolean') {
+        return {
+            type: 'boolean',
+        };
+    }
+    if (schema.type === 'array') {
+        const reSchema = schema;
+        return {
+            type: 'array',
+            items: (0, exports.convertToJsonSchema)(reSchema.items),
+        };
+    }
+    if (schema.type === 'object') {
+        const reSchema = schema;
+        const objectJsonedProperties = Object.keys(reSchema.properties).reduce((acc, key) => {
+            acc[key] = (0, exports.convertToJsonSchema)(reSchema.properties[key]);
+            return acc;
+        }, {});
+        const required = Object.entries(reSchema.properties).reduce((acc, [key, value]) => {
+            if (!value.nullable) {
+                acc.push(key);
+            }
+            return acc;
+        }, []);
+        return {
+            required,
+            type: 'object',
+            properties: objectJsonedProperties,
+        };
+    }
+    if (schema.type === 'union') {
+        const reSchema = schema;
+        return {
+            anyOf: reSchema.anyOf.map((item) => (0, exports.convertToJsonSchema)(item)),
+        };
+    }
+};
+exports.convertToJsonSchema = convertToJsonSchema;

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

@@ -0,0 +1,2 @@
+import { CustomSchema } from './custom-schema';
+export declare const convertToOpenApiSchema: (schema: CustomSchema, route?: string | undefined, method?: string | undefined) => any;

package/lib/schemas/openami-schema.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToOpenApiSchema = void 0;
+const createRouteSchema = (route, method, openApiSchema) => ({
+    [route]: {
+        [method]: {
+            description: 'Autogenerated',
+            responses: {
+                '200': openApiSchema,
+            },
+        },
+    },
+});
+const convertToOpenApiSchema = (schema, route, method) => {
+    if (schema.type === 'string') {
+        return {
+            type: 'string',
+        };
+    }
+    if (schema.type === 'number') {
+        return {
+            type: 'number',
+        };
+    }
+    if (schema.type === 'boolean') {
+        return {
+            type: 'boolean',
+        };
+    }
+    if (schema.type === 'array') {
+        const reSchema = schema;
+        return {
+            type: 'array',
+            items: (0, exports.convertToOpenApiSchema)(reSchema.items),
+        };
+    }
+    if (schema.type === 'object') {
+        const reSchema = schema;
+        const objectJsonedProperties = Object.keys(reSchema.properties).reduce((acc, key) => {
+            acc[key] = (0, exports.convertToOpenApiSchema)(reSchema.properties[key]);
+            return acc;
+        }, {});
+        const required = Object.entries(reSchema.properties).reduce((acc, [key, value]) => {
+            if (!value.nullable) {
+                acc.push(key);
+            }
+            return acc;
+        }, []);
+        return {
+            required,
+            type: 'object',
+            properties: objectJsonedProperties,
+        };
+    }
+    if (schema.type === 'union') {
+        const reSchema = schema;
+        return {
+            anyOf: reSchema.anyOf.map((item) => (0, exports.convertToOpenApiSchema)(item)),
+        };
+    }
+    return createRouteSchema(route, method, schema);
+};
+exports.convertToOpenApiSchema = convertToOpenApiSchema;

package/lib/schemas/project.js

@@ -0,0 +1 @@
+"use strict";

package/lib/server.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="node" />
 import { ServerOptions } from 'ws';
+import Ajv from 'ajv';
 import { BareRequest, CacheOpts } from './request';
 import { CookiesManagerOptions } from './middlewares/cookies/cookie-manager';
 import { HttpMethodsUnion, StatusCodesUnion } from './utils';
@@ -7,7 +8,9 @@ import { CorsOptions } from './middlewares/cors/cors';
 import { WebSocketServer } from './websocket';
 import { Server } from 'http';
 declare type Middleware = (flow: BareRequest) => Promise<void> | void;
-declare type Handler = (flow: BareRequest) => any;
+declare type Handler<H extends {
+    [key: string]: string | undefined;
+}> = (flow: BareRequest<H>) => any;
 declare type ErrorHandler = (err: any, flow: BareRequest, status?: StatusCodesUnion) => void;
 declare type IP = `${number}.${number}.${number}.${number}`;
 declare type RouteOpts<C> = {
@@ -17,15 +20,39 @@ declare type RouteOpts<C> = {
      * Request timeout handler in `ms`
      */
     timeout?: number;
+    builtInRuntime?: {
+        output?: boolean;
+    };
+    middlewares?: Array<Middleware>;
 };
 declare type BareOptions<A extends IP> = {
+    /**
+     * Declare a global middlewares array
+     * Default: []
+     */
     middlewares?: Array<Middleware>;
+    /**
+     * Opt-out request body parsing (de-serialization)
+     * Default `false`
+     */
+    doNotParseBody?: boolean;
+    /**
+     * Opt-in to have a custom swagger per route generation
+     * Default `false`
+     */
+    /**
+     * Opt-in to have a custom runtime JSON Schema checker per routes
+     * Default `false`
+     */
+    enableSchemaValidation?: boolean;
     serverPort?: number;
+    declaredRoutesPaths?: Array<string>;
     /**
      * Address to bind the web server to
      * Default '0.0.0.0'
      */
     serverAddress?: A | 'localhost';
+    setRandomPort?: boolean;
     /**
      * Enable request context storage
      * Default `false`
@@ -52,11 +79,6 @@ declare type BareOptions<A extends IP> = {
      * Log the resolved reverse DNS first hop for remote ip of the client (first proxy)
      */
     reverseDns?: boolean;
-    /**
-     * Exposes a report with the routes usage.
-     * Default `false`
-     */
-    statisticsReport?: boolean;
     /**
      * WebSocket server exposure
      */
@@ -69,16 +91,23 @@ declare type BareOptions<A extends IP> = {
      */
     cors?: boolean | CorsOptions;
 };
+declare type ExtractRouteParams<T extends string> = T extends `${infer Start}:${infer Param}/${infer Rest}` ? {
+    [K in Param | keyof ExtractRouteParams<Rest>]: string;
+} : T extends `${infer Start}:${infer Param}` ? {
+    [K in Param]: string;
+} : {
+    [k: string]: string;
+};
 interface HandlerExposed<K> {
     <R extends `/${string}`, C>(setUp: K extends 'declare' ? {
         route: R;
         options?: RouteOpts<C>;
-        handler: Handler;
+        handler: Handler<ExtractRouteParams<R>>;
         methods: Array<HttpMethodsUnion>;
     } : {
         route: R;
         options?: RouteOpts<C>;
-        handler: Handler;
+        handler: Handler<ExtractRouteParams<R>>;
     }): BareServer<any> & Routes;
 }
 export declare type RouteReport = {
@@ -90,24 +119,23 @@ export declare type Routes = {
     [K in HttpMethodsUnion | 'declare']: HandlerExposed<K>;
 };
 export declare type BareHttpType<A extends IP = any> = BareServer<A> & Routes;
-export declare type ServerMergedType = {
-    new <A extends IP>(args?: BareOptions<A>): BareHttpType<A>;
-};
 export declare class BareServer<A extends IP> {
     #private;
     private bareOptions;
     server: Server;
     ws?: WebSocketServer;
+    ajv?: Ajv;
+    route: Readonly<Routes>;
     constructor(bareOptions?: BareOptions<A>);
-    private mainOptionsSetter;
+    private applyLaunchOptions;
     private applyMiddlewares;
     /**
      * This handler is used in async generated middlewares runtime function
      */
     private resolveMiddleware;
     private setRoute;
-    private registerReport;
     private handleRoute;
+    private resolveResponse;
     private encodeRoute;
     private explodeRoute;
     private basicErrorHandler;
@@ -117,10 +145,11 @@ export declare class BareServer<A extends IP> {
     get runtimeRoute(): Readonly<Routes>;
     start(cb?: (address: string) => void): Promise<void>;
     stop(cb?: (e?: Error) => void): Promise<void>;
+    loadRoutesSchemas(): void;
     use(middleware: Middleware): this;
     getMiddlewares(): Middleware[];
     setCustomErrorHandler(eh: ErrorHandler): void;
+    getServerPort(): number;
     getRoutes(): string[];
 }
-declare const BareHttp: ServerMergedType;
-export { BareHttp };
+export { BareServer as BareHttp };