barehttp 1.0.0 → 2.0.0

package/lib/schemas/custom-schema.js

@@ -0,0 +1,62 @@
+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) => isNullType(nt));
+        const cleanTypes = helpers.cleanNullableTypes(t.getUnionTypes());
+        let returning = {
+            nullable: false,
+            type: 'union',
+        };
+        const transformed = cleanTypes.reduce((acc, ut) => {
+            const regenerated = generateCustomSchema(ut);
+            if (find(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 = 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: 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()]: generateCustomSchema(val.getType()) };
+            return acc;
+        }, { type: 'object', properties: {} });
+        return result;
+    }
+    return {
+        type: getApparentTypeName(t),
+        nullable: false,
+    };
+};

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

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

package/lib/schemas/dirty-tsm.js

@@ -0,0 +1,199 @@
+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');
+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.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.SyntaxKind.CallExpression)
+            ?.getChildren()
+            .find((n) => n.getKind() === ts.SyntaxKind.SyntaxList)
+            ?.getFirstChild()
+            ?.getChildSyntaxList()
+            ?.getChildren()
+            .filter((c) => {
+            return c.getKind() === ts.SyntaxKind.PropertyAssignment && (isHandler(c) || isRoute(c));
+        })
+            .map((c) => {
+            if (isHandler(c)) {
+                return {
+                    type: 'handler',
+                    syntaxList: c
+                        .getChildren()
+                        .find((n) => n.getKind() === ts.SyntaxKind.ArrowFunction ||
+                        n.getKind() === 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) => 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.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.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);
+        }
+        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() || 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);
+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" | "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

@@ -0,0 +1,179 @@
+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');
+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.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));
+// };
+export 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.SyntaxKind.CallExpression)
+            ?.getChildren()
+            .find((n) => n.getKind() === ts.SyntaxKind.SyntaxList)
+            ?.getFirstChild()
+            ?.getChildSyntaxList()
+            ?.getChildren()
+            .filter((c) => {
+            return c.getKind() === ts.SyntaxKind.PropertyAssignment && (isHandler(c) || isRoute(c));
+        })
+            .map((c) => {
+            if (isHandler(c)) {
+                return {
+                    type: 'handler',
+                    methodName,
+                    syntaxList: c
+                        .getChildren()
+                        .find((n) => n.getKind() === ts.SyntaxKind.ArrowFunction ||
+                        n.getKind() === 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) => generateCustomSchema(t));
+        let finalSchema = schemas[0];
+        if (schemas.length > 1) {
+            finalSchema = {
+                type: 'union',
+                nullable: false,
+                anyOf: schemas,
+            };
+        }
+        return {
+            route,
+            methodName,
+            schemas,
+            finalSchema,
+            jsonSchema: convertToJsonSchema(finalSchema),
+        };
+    });
+    return [...schemas];
+};
+const extractReturnStatements = (accumulator, n) => {
+    if (!n)
+        return;
+    if (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.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);
+        }
+        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() || 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;
+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,40 @@
+import { ts } from 'ts-morph';
+import { inspect } from 'util';
+export const helpers = {
+    findCallExpressionFromChildren: (property) => property.getChildren(),
+    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.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
+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();
+    }
+    else {
+        return t.getText();
+    }
+};
+export const getApparentTypeName = (t) => {
+    return t.getApparentType().getText().toLowerCase();
+};
+export function logInternals(data) {
+    console.log(inspect(data, false, null, true));
+}

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

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

package/lib/schemas/json-schema.js

@@ -0,0 +1,48 @@
+export 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: convertToJsonSchema(reSchema.items),
+        };
+    }
+    if (schema.type === 'object') {
+        const reSchema = schema;
+        const objectJsonedProperties = Object.keys(reSchema.properties).reduce((acc, key) => {
+            acc[key] = 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) => convertToJsonSchema(item)),
+        };
+    }
+};

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

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

package/lib/schemas/openami-schema.js

@@ -0,0 +1,59 @@
+const createRouteSchema = (route, method, openApiSchema) => ({
+    [route]: {
+        [method]: {
+            description: 'Autogenerated',
+            responses: {
+                '200': openApiSchema,
+            },
+        },
+    },
+});
+export 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: convertToOpenApiSchema(reSchema.items),
+        };
+    }
+    if (schema.type === 'object') {
+        const reSchema = schema;
+        const objectJsonedProperties = Object.keys(reSchema.properties).reduce((acc, key) => {
+            acc[key] = 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) => convertToOpenApiSchema(item)),
+        };
+    }
+    return createRouteSchema(route, method, schema);
+};

package/lib/schemas/project.d.ts

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

package/lib/schemas/project.js

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