barehttp 0.4.0 → 0.5.0

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;
+}[];

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";