barehttp 0.6.0 → 2.0.0

package/lib/schemas/custom-schema.js

@@ -1,25 +1,19 @@
-"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 };
+import find from 'lodash/find.js';
+import { getApparentTypeName, getTypeGenericText, helpers, isFinalType, isNullType, } from './helpers.js';
+export const generateCustomSchema = (t) => {
+    if (isFinalType(t)) {
+        return { type: 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());
+        const nulled = t.getUnionTypes().some((nt) => isNullType(nt));
+        const cleanTypes = 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))
+            const regenerated = generateCustomSchema(ut);
+            if (find(acc, regenerated))
                 return acc;
             return acc.concat(regenerated);
         }, []);
@@ -36,7 +30,7 @@ const generateCustomSchema = (t) => {
     }
     if (t.isIntersection()) {
         return t.getIntersectionTypes().reduce((acc, it) => {
-            const generatedSchema = (0, exports.generateCustomSchema)(it);
+            const generatedSchema = generateCustomSchema(it);
             if (Object.keys(acc).length === 0) {
                 acc = generatedSchema;
                 return acc;
@@ -50,20 +44,19 @@ const generateCustomSchema = (t) => {
     if (t.isArray()) {
         return {
             type: 'array',
-            items: (0, exports.generateCustomSchema)(t.getArrayElementType()),
+            items: 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()) };
+            acc.properties = { ...acc.properties, [ci.getName()]: generateCustomSchema(val.getType()) };
             return acc;
         }, { type: 'object', properties: {} });
         return result;
     }
     return {
-        type: (0, helpers_1.getApparentTypeName)(t),
+        type: getApparentTypeName(t),
         nullable: false,
     };
 };
-exports.generateCustomSchema = generateCustomSchema;

package/lib/schemas/dirty-tsm.js

@@ -1,9 +1,7 @@
-"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' });
+import { Project, ts } from 'ts-morph';
+import { generateCustomSchema } from './custom-schema.js';
+import { isFinalType, logInternals } from './helpers.js';
+const project = new Project({ tsConfigFilePath: 'tsconfig.json' });
 project.enableLogging();
 const sourceFile = project.getSourceFile('server.ts');
 const tp = sourceFile?.getClass('BareServer')?.getMember('route');
@@ -14,7 +12,7 @@ function returnFinder(route, base) {
         throw new Error('No project been allocated, theres some issue');
     }
     const refsAcrossProject = base
-        .getChildrenOfKind(ts_morph_1.ts.SyntaxKind.Identifier)[0]
+        .getChildrenOfKind(ts.SyntaxKind.Identifier)[0]
         .findReferences()[0]
         .getReferences()
         ?.filter((re) => re.compilerObject.fileName.includes(route));
@@ -26,14 +24,14 @@ function returnFinder(route, base) {
         return ref
             .getNode()
             .getAncestors()
-            .find((n) => n.getKind() === ts_morph_1.ts.SyntaxKind.CallExpression)
+            .find((n) => n.getKind() === ts.SyntaxKind.CallExpression)
             ?.getChildren()
-            .find((n) => n.getKind() === ts_morph_1.ts.SyntaxKind.SyntaxList)
+            .find((n) => n.getKind() === ts.SyntaxKind.SyntaxList)
             ?.getFirstChild()
             ?.getChildSyntaxList()
             ?.getChildren()
             .filter((c) => {
-            return c.getKind() === ts_morph_1.ts.SyntaxKind.PropertyAssignment && (isHandler(c) || isRoute(c));
+            return c.getKind() === ts.SyntaxKind.PropertyAssignment && (isHandler(c) || isRoute(c));
         })
             .map((c) => {
             if (isHandler(c)) {
@@ -41,8 +39,8 @@ function returnFinder(route, base) {
                     type: 'handler',
                     syntaxList: c
                         .getChildren()
-                        .find((n) => n.getKind() === ts_morph_1.ts.SyntaxKind.ArrowFunction ||
-                        n.getKind() === ts_morph_1.ts.SyntaxKind.FunctionExpression)
+                        .find((n) => n.getKind() === ts.SyntaxKind.ArrowFunction ||
+                        n.getKind() === ts.SyntaxKind.FunctionExpression)
                         ?.getLastChild()
                         ?.getChildSyntaxList(),
                 };
@@ -78,7 +76,7 @@ function returnFinder(route, base) {
         handler: getReturnStatements(routeCombination.handler),
     }));
     const schemas = perRoute.map(({ handler, route }) => {
-        const schemas = handler.map((t) => (0, custom_schema_1.generateCustomSchema)(t));
+        const schemas = handler.map((t) => generateCustomSchema(t));
         let finalSchema = schemas[0];
         if (schemas.length > 1) {
             finalSchema = {
@@ -130,7 +128,7 @@ function returnFinder(route, base) {
 const extractReturnStatements = (accumulator, n) => {
     if (!n)
         return;
-    if (ts_morph_1.ts.SyntaxKind.IfStatement === n.getKind()) {
+    if (ts.SyntaxKind.IfStatement === n.getKind()) {
         const thenProp = n.getNodeProperty('thenStatement');
         const elseProp = n.getNodeProperty('elseStatement');
         const thenSyntax = thenProp?.getChildSyntaxList();
@@ -141,10 +139,10 @@ const extractReturnStatements = (accumulator, n) => {
     }
     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 findReturn = cleanChildren.find((c) => c.getKind() === ts.SyntaxKind.ReturnStatement);
+        const thereIf = cleanChildren.find((c) => c.getKind() === ts.SyntaxKind.IfStatement);
+        const thereWhile = cleanChildren.find((c) => c.getKind() === ts.SyntaxKind.WhileKeyword);
+        const thereFor = cleanChildren.find((c) => c.getKind() === ts.SyntaxKind.ForStatement);
         const syntaxList = n.getChildSyntaxList();
         if (findReturn) {
             accumulator.push(findReturn);
@@ -163,7 +161,7 @@ const getReturnStatements = (n) => {
     return accumulator
         .map((r) => r.getChildren().find((c) => {
         const type = c.getType();
-        return type.isObject() || (0, helpers_1.isFinalType)(type);
+        return type.isObject() || isFinalType(type);
     }))
         .filter((n) => n)
         .map((acc) => acc.getType());
@@ -192,7 +190,7 @@ const getReturnStatements = (n) => {
     //   .map((v) => v!.getType());
 };
 // returnFinder('examples', tp);
-(0, helpers_1.logInternals)(returnFinder('examples', tp));
+logInternals(returnFinder('examples', tp));
 // logInternals(returnFinder('examples', tp).map((s) => convertToJsonSchema(s)));
 // console.log(tp);
 // logInternals(getReturnStatements(res!)?.map((t) => regenerateTypeSchema(t!)));

package/lib/schemas/generator.d.ts

@@ -1,7 +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;
+    methodName: "get" | "options" | "post" | "put" | "delete" | "patch" | "head";
+    schemas: import("./custom-schema.js").CustomSchema[];
+    finalSchema: import("./custom-schema.js").CustomSchema;
     jsonSchema: any;
 }[];

package/lib/schemas/generator.js

@@ -1,18 +1,12 @@
-"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);
+import { Project, ts } from 'ts-morph';
+import { generateCustomSchema } from './custom-schema.js';
+import { isFinalType, isHandler, isRoute } from './helpers.js';
+import { convertToJsonSchema } from './json-schema.js';
+import path from 'path';
+import { existsSync } from 'fs';
+const project = new Project({ tsConfigFilePath: path.join(process.cwd(), '/tsconfig.json') });
+const nodeModulesFile = path.join(process.cwd(), 'node_modules', 'barehttp');
+const isInstalledPackage = existsSync(nodeModulesFile);
 if (isInstalledPackage)
     project.addSourceFileAtPath(nodeModulesFile + '/lib/server.d.ts');
 const serverSourceFile = project.getSourceFile('server.d.ts');
@@ -26,7 +20,7 @@ const getReferences = (fileRoute, target) => {
     if (!target)
         return [];
     return target
-        ?.getChildrenOfKind(ts_morph_1.ts.SyntaxKind.Identifier)[0]
+        ?.getChildrenOfKind(ts.SyntaxKind.Identifier)[0]
         .findReferences()[0]
         .getReferences()
         ?.filter((re) => {
@@ -44,7 +38,7 @@ const getReferences = (fileRoute, target) => {
 //     .filter((p) => p?.getKind() === ts.SyntaxKind.CallExpression)
 //     .map((p) => p?.getNodeProperty('arguments' as any));
 // };
-const generateRouteSchema = (fileRouteToDeclarations) => {
+export const generateRouteSchema = (fileRouteToDeclarations) => {
     if (!routes && !runtimeRoutes) {
         throw new Error('No project been allocated, theres some issue');
     }
@@ -65,24 +59,24 @@ const generateRouteSchema = (fileRouteToDeclarations) => {
         return ref
             .getNode()
             .getAncestors()
-            .find((n) => n.getKind() === ts_morph_1.ts.SyntaxKind.CallExpression)
+            .find((n) => n.getKind() === ts.SyntaxKind.CallExpression)
             ?.getChildren()
-            .find((n) => n.getKind() === ts_morph_1.ts.SyntaxKind.SyntaxList)
+            .find((n) => n.getKind() === 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));
+            return c.getKind() === ts.SyntaxKind.PropertyAssignment && (isHandler(c) || isRoute(c));
         })
             .map((c) => {
-            if ((0, helpers_1.isHandler)(c)) {
+            if (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)
+                        .find((n) => n.getKind() === ts.SyntaxKind.ArrowFunction ||
+                        n.getKind() === ts.SyntaxKind.FunctionExpression)
                         ?.getLastChild()
                         ?.getChildSyntaxList(),
                 };
@@ -122,7 +116,7 @@ const generateRouteSchema = (fileRouteToDeclarations) => {
     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));
+        const schemas = handler.map((t) => generateCustomSchema(t));
         let finalSchema = schemas[0];
         if (schemas.length > 1) {
             finalSchema = {
@@ -136,16 +130,15 @@ const generateRouteSchema = (fileRouteToDeclarations) => {
             methodName,
             schemas,
             finalSchema,
-            jsonSchema: (0, json_schema_1.convertToJsonSchema)(finalSchema),
+            jsonSchema: convertToJsonSchema(finalSchema),
         };
     });
     return [...schemas];
 };
-exports.generateRouteSchema = generateRouteSchema;
 const extractReturnStatements = (accumulator, n) => {
     if (!n)
         return;
-    if (ts_morph_1.ts.SyntaxKind.IfStatement === n.getKind()) {
+    if (ts.SyntaxKind.IfStatement === n.getKind()) {
         const thenProp = n.getNodeProperty('thenStatement');
         const elseProp = n.getNodeProperty('elseStatement');
         const thenSyntax = thenProp?.getChildSyntaxList();
@@ -156,10 +149,10 @@ const extractReturnStatements = (accumulator, n) => {
     }
     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 findReturn = cleanChildren.find((c) => c.getKind() === ts.SyntaxKind.ReturnStatement);
+        const thereIf = cleanChildren.find((c) => c.getKind() === ts.SyntaxKind.IfStatement);
+        const thereWhile = cleanChildren.find((c) => c.getKind() === ts.SyntaxKind.WhileKeyword);
+        const thereFor = cleanChildren.find((c) => c.getKind() === ts.SyntaxKind.ForStatement);
         const syntaxList = n.getChildSyntaxList();
         if (findReturn) {
             accumulator.push(findReturn);
@@ -173,7 +166,7 @@ const extractReturnStatements = (accumulator, n) => {
 const getTypes = (nodes) => nodes
     .map((r) => r.getChildren().find((c) => {
     const type = c.getType();
-    return type.isObject() || (0, helpers_1.isFinalType)(type);
+    return type.isObject() || isFinalType(type);
 }))
     .filter((n) => n && typeof n.getType === 'function')
     .map((acc) => acc.getType());

package/lib/schemas/helpers.d.ts

@@ -18,7 +18,7 @@ export declare const helpers: {
 };
 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';
+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;

package/lib/schemas/helpers.js

@@ -1,37 +1,30 @@
-"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 = {
+import { ts } from 'ts-morph';
+import { inspect } from 'util';
+export const 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),
+    findCallExpression: (n) => n.find((x) => x.getKind() === ts.SyntaxKind.CallExpression),
+    findSyntaxList: (property) => property.getChildren().find((x) => x.getKind() === 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)),
+        .find((x) => x.getKind() === ts.SyntaxKind.ArrowFunction ||
+        x.getKind() === ts.SyntaxKind.FunctionExpression),
+    findReturnStatement: (property) => property.getChildren().find((x) => x.getKind() === ts.SyntaxKind.ReturnStatement),
+    findIdentifier: (property) => property.getChildren().find((x) => x.getKind() === ts.SyntaxKind.ReturnStatement),
+    findObjectLiteralExpressionFromChildren: (property) => property.getChildren().find((x) => x.getKind() === ts.SyntaxKind.ObjectLiteralExpression),
+    findObjectLiteralExpression: (n) => n.find((x) => x.getKind() === ts.SyntaxKind.ObjectLiteralExpression),
+    filterPropertyAssignmentFromChildren: (property) => property.getChildren().filter((x) => x.getKind() === ts.SyntaxKind.PropertyAssignment),
+    findPropertyAssignmentFromChildren: (property) => property.getChildren().find((x) => x.getKind() === ts.SyntaxKind.PropertyAssignment),
+    findPropertyAssignment: (n) => n.find((x) => x.getKind() === ts.SyntaxKind.PropertyAssignment),
+    findUnionTypeNodeFromChildren: (n) => n.getChildren().find((x) => x.getKind() === ts.SyntaxKind.UnionType),
+    findNullableTypeFromChildren: (n) => n.getChildren().find((x) => isNullType(x.getType())),
+    filterNullableTypeFromChildren: (n) => n.getChildren().filter((x) => !isNullType(x.getType())),
+    cleanNullableTypes: (t) => t.filter((x) => !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) => {
+export const isFinalType = (t) => t.isNumber() || t.isString() || t.isBoolean() || t.isLiteral();
+export const isNullType = (t) => t.isNull() || t.isUndefined();
+export const isHandler = (c) => c.getSymbol()?.getName() === 'handler';
+export const isRoute = (c) => c.getSymbol()?.getName() === 'route';
+export const getTypeGenericText = (t) => {
     if (t.isStringLiteral() || t.isNumberLiteral() || t.isBooleanLiteral()) {
         return t.getBaseTypeOfLiteralType().getText();
     }
@@ -39,12 +32,9 @@ const getTypeGenericText = (t) => {
         return t.getText();
     }
 };
-exports.getTypeGenericText = getTypeGenericText;
-const getApparentTypeName = (t) => {
+export const getApparentTypeName = (t) => {
     return t.getApparentType().getText().toLowerCase();
 };
-exports.getApparentTypeName = getApparentTypeName;
-function logInternals(data) {
-    console.log((0, util_1.inspect)(data, false, null, true));
+export function logInternals(data) {
+    console.log(inspect(data, false, null, true));
 }
-exports.logInternals = logInternals;

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

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

package/lib/schemas/json-schema.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertToJsonSchema = void 0;
-const convertToJsonSchema = (schema) => {
+export const convertToJsonSchema = (schema) => {
     if (schema.type === 'string') {
         return {
             type: 'string',
@@ -21,13 +18,13 @@ const convertToJsonSchema = (schema) => {
         const reSchema = schema;
         return {
             type: 'array',
-            items: (0, exports.convertToJsonSchema)(reSchema.items),
+            items: 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]);
+            acc[key] = convertToJsonSchema(reSchema.properties[key]);
             return acc;
         }, {});
         const required = Object.entries(reSchema.properties).reduce((acc, [key, value]) => {
@@ -45,8 +42,7 @@ const convertToJsonSchema = (schema) => {
     if (schema.type === 'union') {
         const reSchema = schema;
         return {
-            anyOf: reSchema.anyOf.map((item) => (0, exports.convertToJsonSchema)(item)),
+            anyOf: reSchema.anyOf.map((item) => convertToJsonSchema(item)),
         };
     }
 };
-exports.convertToJsonSchema = convertToJsonSchema;

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

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

package/lib/schemas/openami-schema.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertToOpenApiSchema = void 0;
 const createRouteSchema = (route, method, openApiSchema) => ({
     [route]: {
         [method]: {
@@ -11,7 +8,7 @@ const createRouteSchema = (route, method, openApiSchema) => ({
         },
     },
 });
-const convertToOpenApiSchema = (schema, route, method) => {
+export const convertToOpenApiSchema = (schema, route, method) => {
     if (schema.type === 'string') {
         return {
             type: 'string',
@@ -31,13 +28,13 @@ const convertToOpenApiSchema = (schema, route, method) => {
         const reSchema = schema;
         return {
             type: 'array',
-            items: (0, exports.convertToOpenApiSchema)(reSchema.items),
+            items: 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]);
+            acc[key] = convertToOpenApiSchema(reSchema.properties[key]);
             return acc;
         }, {});
         const required = Object.entries(reSchema.properties).reduce((acc, [key, value]) => {
@@ -55,9 +52,8 @@ const convertToOpenApiSchema = (schema, route, method) => {
     if (schema.type === 'union') {
         const reSchema = schema;
         return {
-            anyOf: reSchema.anyOf.map((item) => (0, exports.convertToOpenApiSchema)(item)),
+            anyOf: reSchema.anyOf.map((item) => convertToOpenApiSchema(item)),
         };
     }
     return createRouteSchema(route, method, schema);
 };
-exports.convertToOpenApiSchema = convertToOpenApiSchema;

package/lib/schemas/project.d.ts

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

package/lib/schemas/project.js

@@ -1 +1 @@
-"use strict";
+export {};

package/lib/server.d.ts

@@ -1,19 +1,18 @@
-/// <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';
-import { CorsOptions } from './middlewares/cors/cors';
-import { WebSocketServer } from './websocket';
+import { Ajv } from 'ajv';
+import { BareRequest, CacheOpts } from './request.js';
+import { CookiesManagerOptions } from './middlewares/cookies/cookie-manager.js';
+import { HttpMethodsUnion, StatusCodesUnion } from './utils/index.js';
+import { CorsOptions } from './middlewares/cors/cors.js';
+import { WebSocketServer } from './websocket.js';
 import { Server } from 'http';
-declare type Middleware = (flow: BareRequest) => Promise<void> | void;
-declare type Handler<H extends {
+type Middleware = (flow: BareRequest) => Promise<void> | void;
+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> = {
+type ErrorHandler = (err: any, flow: BareRequest, status?: StatusCodesUnion) => void;
+type IP = `${number}.${number}.${number}.${number}`;
+type RouteOpts<C> = {
     disableCache?: C extends true ? C : undefined;
     cache?: C extends true ? undefined : CacheOpts;
     /**
@@ -25,7 +24,7 @@ declare type RouteOpts<C> = {
     };
     middlewares?: Array<Middleware>;
 };
-declare type BareOptions<A extends IP> = {
+type BareOptions<A extends IP> = {
     /**
      * Declare a global middlewares array
      * Default: []
@@ -91,9 +90,9 @@ declare type BareOptions<A extends IP> = {
      */
     cors?: boolean | CorsOptions;
 };
-declare type ExtractRouteParams<T extends string> = T extends `${infer Start}:${infer Param}/${infer Rest}` ? {
+type ExtractRouteParams<T extends string> = T extends `${string}:${infer Param}/${infer Rest}` ? {
     [K in Param | keyof ExtractRouteParams<Rest>]: string;
-} : T extends `${infer Start}:${infer Param}` ? {
+} : T extends `${string}:${infer Param}` ? {
     [K in Param]: string;
 } : {
     [k: string]: string;
@@ -110,15 +109,15 @@ interface HandlerExposed<K> {
         handler: Handler<ExtractRouteParams<R>>;
     }): BareServer<any> & Routes;
 }
-export declare type RouteReport = {
+export type RouteReport = {
     hits: number;
     success: number;
     fails: number;
 };
-export declare type Routes = {
+export type Routes = {
     [K in HttpMethodsUnion | 'declare']: HandlerExposed<K>;
 };
-export declare type BareHttpType<A extends IP = any> = BareServer<A> & Routes;
+export type BareHttpType<A extends IP = any> = BareServer<A> & Routes;
 export declare class BareServer<A extends IP> {
     #private;
     private bareOptions;