@bagelink/sdk 0.0.464 → 0.0.471

package/src/openAPITools/functionGenerator.ts

@@ -1,50 +1,58 @@
 import type {
-	OperationObject, ParameterObject, PathsObject, RequestBodyObject, ResponseObject, ResponsesObject,
-} from './openApiTypes';
+	OperationObject,
+	ParameterObject,
+	PathsObject,
+	RequestBodyObject,
+	ResponseObject,
+	ResponsesObject,
+} from './openApiTypes'
 import {
 	cleanPath,
 	formatType,
-	formatVarType, schemaToType, toCamelCase, toPascalCase,
-} from './utils';
+	formatVarType,
+	schemaToType,
+	toCamelCase,
+	toPascalCase,
+} from './utils'
 
-const allTypes: string[] = [];
+const allTypes: string[] = []
 
 function collectTypeForImportStatement(typeName: string) {
-	typeName = typeName.trim().replace('[]', '');
+	typeName = typeName.trim().replace('[]', '')
 	if (typeName.includes('|')) {
 		typeName.split('|').forEach(
-			(singleType) => collectTypeForImportStatement(singleType),
-		);
-		return;
+			(singleType) => { collectTypeForImportStatement(singleType) },
+		)
+		return
 	}
-	const primitiveTypes = ['string', 'number', 'boolean', 'null', 'void', 'any', 'Record<string, any>'];
-	const isPrimitive = primitiveTypes.includes(typeName);
-	typeName = formatType(typeName);
-	if (!typeName || isPrimitive) return;
-	if (!allTypes.includes(typeName)) allTypes.push(typeName);
+	const primitiveTypes = ['string', 'number', 'boolean', 'null', 'void', 'any', 'Record<string, any>']
+	const isPrimitive = primitiveTypes.includes(typeName)
+	typeName = formatType(typeName)
+	if (!typeName || isPrimitive) return
+	if (!allTypes.includes(typeName)) allTypes.push(typeName)
 }
 
 function getResponseType(response: ResponseObject): string | null {
-	const mediaTypeObject = response.content?.['application/json'];
-	if (!mediaTypeObject || !mediaTypeObject.schema) return null;
-	const responseType = schemaToType(mediaTypeObject.schema);
-	collectTypeForImportStatement(responseType);
-	return responseType;
+	const mediaTypeObject = response.content?.['application/json']
+	if (!mediaTypeObject || !mediaTypeObject.schema) return null
+	const responseType = schemaToType(mediaTypeObject.schema)
+	collectTypeForImportStatement(responseType)
+	return responseType
 }
 
 function generateResponseType(responses?: ResponsesObject): string {
-	if (!responses) return '';
-	const types: string[] = [];
+	if (!responses) return ''
+	const types: string[] = []
 
 	for (const [statusCode, response] of Object.entries(responses)) {
 		if (statusCode.startsWith('2')) {
-			const responseType = getResponseType(response);
+			const responseType = getResponseType(response)
 			if (responseType && responseType !== 'any') {
-				types.push(responseType);
+				types.push(responseType)
 			}
 		}
 	}
-	return types?.join(' | ');
+	return types.join(' | ')
 }
 
 /**
@@ -65,41 +73,41 @@ function generateAxiosFunction(
 	parameters: any,
 	requestBodyPayload: string,
 ): string {
-	let axiosFunction = `async (${allParams})${responseTypeStr} => axios.${method}(`;
-	const paramStr = parameters?.config?.params ? `, { params: {${parameters.config.params}} }` : '';
+	let axiosFunction = `async (${allParams})${responseTypeStr} => axios.${method}(`
+	const paramStr = parameters?.config?.params ? `, { params: {${parameters.config.params}} }` : ''
 
 	if (['get', 'delete'].includes(method)) {
-		axiosFunction += `${formattedPath}${paramStr}`;
+		axiosFunction += `${formattedPath}${paramStr}`
 	} else if (['post', 'put', 'patch', 'delete'].includes(method)) {
-		const bodyVar = requestBodyPayload ? `${requestBodyPayload}` : '{}';
+		const bodyVar = requestBodyPayload ? `${requestBodyPayload}` : '{}'
 
-		axiosFunction += `${formattedPath}, ${bodyVar}${paramStr}`;
+		axiosFunction += `${formattedPath}, ${bodyVar}${paramStr}`
 	}
-	axiosFunction += ')';
-	return axiosFunction;
+	axiosFunction += ')'
+	return axiosFunction
 }
 
-const pathParamRegex = /\{([^}]+)\}/g;
-const getParamsFromPath = (path: string) => {
-	const params = path.match(pathParamRegex)?.map((p) => p.slice(1, -1));
-	return params;
-};
+const pathParamRegex = /\{([^}]+)\}/g
+function getParamsFromPath(path: string) {
+	const params = path.match(pathParamRegex)?.map(p => p.slice(1, -1))
+	return params
+}
 
 function formatPathWithParams(path: string) {
-	const params = getParamsFromPath(path);
-	const formattedPath = params ? `\`${path.replace(pathParamRegex, (v) => `$${toCamelCase(v)}`)}\`` : `'${path}'`;
-	return formattedPath;
+	const params = getParamsFromPath(path)
+	const formattedPath = params ? `\`${path.replace(pathParamRegex, v => `$${toCamelCase(v)}`)}\`` : `'${path}'`
+	return formattedPath
 }
 
 function generateRequestBody(requestBody?: RequestBodyObject): Record<string, string> {
-	const bodySchema = requestBody?.content?.['application/json']?.schema;
-	if (!bodySchema) return { requestBodyParam: '', requestBodyPayload: '' };
-	const requestBodyType = schemaToType(bodySchema);
-	collectTypeForImportStatement(requestBodyType);
-	const requestBodyPayload = toCamelCase(bodySchema?.title) || toCamelCase(requestBodyType) || 'requestBody';
-	const defaultValue = requestBody?.content?.['application/json']?.schema?.default;
-	const requestBodyParam = formatVarType(requestBodyPayload, bodySchema, defaultValue);
-	return { requestBodyParam, requestBodyPayload };
+	const bodySchema = requestBody?.content['application/json']?.schema
+	if (!bodySchema) return { requestBodyParam: '', requestBodyPayload: '' }
+	const requestBodyType = schemaToType(bodySchema)
+	collectTypeForImportStatement(requestBodyType)
+	const requestBodyPayload = toCamelCase(bodySchema.title) || toCamelCase(requestBodyType) || 'requestBody'
+	const defaultValue = requestBody.content['application/json'].schema?.default
+	const requestBodyParam = formatVarType(requestBodyPayload, bodySchema, defaultValue)
+	return { requestBodyParam, requestBodyPayload }
 }
 
 /**
@@ -109,137 +117,139 @@ function generateRequestBody(requestBody?: RequestBodyObject): Record<string, st
  * @returns A string representing all combined parameters.
  */
 function combineAllParams(parameters: { params?: string }, requestBodyParam: string): string {
-	let allParamsArray: string[] = [];
-	if (parameters && parameters.params) allParamsArray = parameters.params.split(',').map((p) => p.trim());
-	if (requestBodyParam) allParamsArray.push(requestBodyParam.trim());
+	let allParamsArray: string[] = []
+	if (parameters && parameters.params) allParamsArray = parameters.params.split(',').map(p => p.trim())
+	if (requestBodyParam) allParamsArray.push(requestBodyParam.trim())
 
 	allParamsArray = allParamsArray
-		.filter((p) => p).sort((a, b) => (a.includes('?') ? 1 : -1) - (b.includes('?') ? 1 : -1));
+		.filter(p => p).sort((a, b) => (a.includes('?') ? 1 : -1) - (b.includes('?') ? 1 : -1))
 
-	return allParamsArray.join(', ');
+	return allParamsArray.join(', ')
 }
 
 function generateFunctionParameters(params?: ParameterObject[]) {
-	if (!params || params.length === 0) return {};
+	if (!params || params.length === 0) return {}
 
-	const functionParams: string[] = [];
-	const paramList: string[] = [];
+	const functionParams: string[] = []
+	const paramList: string[] = []
 
 	for (const param of params) {
-		const paramType = schemaToType(param.schema);
-		collectTypeForImportStatement(paramType);
-		const paramName = param.name;
-		const varName = toCamelCase(param.name) || 'param';
+		const paramType = schemaToType(param.schema)
+		collectTypeForImportStatement(paramType)
+		const paramName = param.name
+		const varName = toCamelCase(param.name) || 'param'
 		if (param.in === 'path' || param.in === 'query' || param.in === 'header') {
-			const defaultValue = param?.schema?.default;
-			const varType = formatVarType(varName, param.schema, param.required, defaultValue);
-			functionParams.push(varType);
+			const defaultValue = param.schema.default
+			const varType = formatVarType(varName, param.schema, param.required, defaultValue)
+			functionParams.push(varType)
 		}
 		if (param.in === 'query' || param.in === 'header') {
-			if (paramName === varName) paramList.push(paramName);
-			else paramList.push(`'${paramName}': ${varName}`);
+			if (paramName === varName) paramList.push(paramName)
+			else paramList.push(`'${paramName}': ${varName}`)
 		}
 	}
 
-	const paramsString = functionParams.join(', ');
-	const config: { params?: string } = {};
+	const paramsString = functionParams.join(', ')
+	const config: { params?: string } = {}
 
-	if (paramList.length > 0) config.params = paramList.join(', ');
-	return { params: paramsString, config };
+	if (paramList.length > 0) config.params = paramList.join(', ')
+	return { params: paramsString, config }
 }
 
 function generateFunctionForOperation(method: string, path: string, operation: OperationObject): string {
-	if (!operation) return '';
-	const parameters = generateFunctionParameters(operation.parameters);
-	const responseType = generateResponseType(operation.responses);
-	const formattedPath = formatPathWithParams(path);
-	const { requestBodyParam, requestBodyPayload } = generateRequestBody(operation.requestBody);
-	const allParams = combineAllParams(parameters, requestBodyParam);
-	const responseTypeStr = responseType ? `: Promise<AxiosResponse<${responseType}>>` : '';
-	return generateAxiosFunction(method, formattedPath, allParams, responseTypeStr, parameters, requestBodyPayload);
+	if (!operation) return ''
+	const parameters = generateFunctionParameters(operation.parameters)
+	const responseType = generateResponseType(operation.responses)
+	const formattedPath = formatPathWithParams(path)
+	const { requestBodyParam, requestBodyPayload } = generateRequestBody(operation.requestBody)
+	const allParams = combineAllParams(parameters, requestBodyParam)
+	const responseTypeStr = responseType ? `: Promise<AxiosResponse<${responseType}>>` : ''
+	return generateAxiosFunction(method, formattedPath, allParams, responseTypeStr, parameters, requestBodyPayload)
 }
 
-const generateRandomString = () => Math.random().toString(36).substring(7);
+const generateRandomString = () => Math.random().toString(36).substring(7)
 
 function fileTemplate(tsString: string, typeForImport: string[], baseURL: string) {
 	const templateCode = (
-		`import axios as ax from 'axios';
+		`import ax from 'axios';
 		 import type { AxiosResponse } from 'axios';
 		 import type {${typeForImport.join(', ')}} from './types.d';
 
 	const axios = ax.create({baseURL:${baseURL}});
 	${tsString}`
-	);
-	const doubleQuoteRegex = /"([^"]+)":/g;
-	return templateCode.replace(doubleQuoteRegex, '$1:');
+	)
+	const doubleQuoteRegex = /"([^"]+)":/g
+	return templateCode.replace(doubleQuoteRegex, '$1:')
 }
 
-const functionsInventory: Record<string, any> = {};
-const pathOperations: any[] = [];
+const functionsInventory: Record<string, any> = {}
+const pathOperations: any[] = []
 
-const hasConflict = (path: string, method: string) => {
-	const cleanPathName = path.split('/').filter((p) => p && !p.match(/\{|\}/)).join('/');
-	const matchingPaths = pathOperations.filter((p) => p.path === cleanPathName && p.method === method);
-	pathOperations.push({ path: cleanPathName, method });
-	return matchingPaths.length > 0;
-};
+function hasConflict(path: string, method: string) {
+	const cleanPathName = path.split('/').filter(p => p && !p.match(/\{|\}/)).join('/')
+	const matchingPaths = pathOperations.filter(p => p.path === cleanPathName && p.method === method)
+	pathOperations.push({ path: cleanPathName, method })
+	return matchingPaths.length > 0
+}
 
 // Creates a placeholder for a function and stores its body in the inventory
-const createFunctionPlaceholder = (path: string, method: string, operation: any) => {
-	const funcID = generateRandomString();
-	functionsInventory[funcID] = generateFunctionForOperation(method, path, operation);
-	return funcID;
-};
+function createFunctionPlaceholder(path: string, method: string, operation: any) {
+	const funcID = generateRandomString()
+	functionsInventory[funcID] = generateFunctionForOperation(method, path, operation)
+	return funcID
+}
 
 function handlePathSegment(
 	path: string,
 	operation: any,
 	existingObj: Record<string, any> | null = null,
 ) {
-	const methods = Object.keys(operation);
-	const obj: Record<string, any> = {};
+	const methods = Object.keys(operation)
+	const obj: Record<string, any> = {}
 	for (const method of methods) {
-		let functionName = method.toLowerCase();
+		let functionName = method.toLowerCase()
 		if (hasConflict(path, method)) {
-			const params: string[] | undefined = getParamsFromPath(path);
-			functionName += (params ? `By${toPascalCase(params?.pop() || '')}` : 'All');
+			const params: string[] | undefined = getParamsFromPath(path)
+			functionName += (params ? `By${toPascalCase(params.pop() || '')}` : 'All')
 		}
-		obj[functionName] = createFunctionPlaceholder(path, method, operation[method]);
+		obj[functionName] = createFunctionPlaceholder(path, method, operation[method])
 	}
-	return { ...obj, ...existingObj };
+	return { ...obj, ...existingObj }
 }
 
 export function generateFunctions(paths: PathsObject, baseURL: string) {
-	let tsString = '';
-	const body: Record<string, any> = {};
-	const allPathsClean = Object.keys(paths).map(cleanPath);
+	let tsString = ''
+	const body: Record<string, any> = {}
+	const allPathsClean = Object.keys(paths).map(cleanPath)
 	for (const [path, operation] of Object.entries(paths)) {
-		const splitPath = path.split('/').filter((p) => p && !p.match(/\{|\}/));
+		const splitPath = path.split('/').filter(p => p && !p.match(/\{|\}/))
 		splitPath.reduce((acc, key: string, index: number, array: string[]) => {
-			const objFuncKey = toCamelCase(key);
-			if (!objFuncKey) return acc;
-			const methods = Object.keys(operation);
+			const objFuncKey = toCamelCase(key)
+			if (!objFuncKey) return acc
+			const methods = Object.keys(operation)
 			if (
-				index === array.length - 1 &&
-				methods.length === 1 &&
-				allPathsClean.filter((p) => p === cleanPath(path)).length === 1
+				index === array.length - 1
+				&& methods.length === 1
+				&& allPathsClean.filter(p => p === cleanPath(path)).length === 1
 			) {
-				const method: string = methods[0];
-				const opp: any = { ...operation }[method];
-				acc[objFuncKey] = createFunctionPlaceholder(path, methods[0], opp);
+				const method: string = methods[0]
+				const opp: any = { ...operation }[method]
+				acc[objFuncKey] = createFunctionPlaceholder(path, methods[0], opp)
 			} else if (
 				index === array.length - 1
-			) acc[objFuncKey] = handlePathSegment(path, operation, acc[objFuncKey]);
-			else if (!acc[objFuncKey] || typeof acc[objFuncKey] !== 'object') acc[objFuncKey] = {};
-			return acc[objFuncKey];
-		}, body);
+			) { acc[objFuncKey] = handlePathSegment(path, operation, acc[objFuncKey])
+			}
+			else if (!acc[objFuncKey] || typeof acc[objFuncKey] !== 'object') { acc[objFuncKey] = {}
+			}
+			return acc[objFuncKey]
+		}, body)
 	}
 	for (const [parent, object] of Object.entries(body)) {
-		tsString += `export const ${parent} = ${JSON.stringify(object, null, 2)};\n`;
+		tsString += `export const ${parent} = ${JSON.stringify(object, null, 2)};\n`
 	}
 	Object.entries(functionsInventory).forEach(([key, value]) => {
-		tsString = tsString.replace(`"${key}"`, value);
-	});
-	tsString = fileTemplate(tsString, allTypes, baseURL);
-	return tsString;
+		tsString = tsString.replace(`"${key}"`, value)
+	})
+	tsString = fileTemplate(tsString, allTypes, baseURL)
+	return tsString
 }

package/src/openAPITools/index.ts

@@ -1,25 +1,25 @@
-import axios from 'axios';
-import type { OpenAPIDocument } from './openApiTypes';
-import { generateTypes } from './typeGenerator';
-import { generateFunctions } from './functionGenerator';
+import axios from 'axios'
+import type { OpenAPIDocument } from './openApiTypes'
+import { generateTypes } from './typeGenerator'
+import { generateFunctions } from './functionGenerator'
 
-type OpenAPIResponse = {
-	types: string;
-	code: string;
+interface OpenAPIResponse {
+	types: string
+	code: string
 }
 
 export default async (openApiUrl: string, baseURL: string): Promise<OpenAPIResponse> => {
 	try {
-		const { data: openApi } = await axios.get<OpenAPIDocument>(openApiUrl);
-		const schemas = openApi.components?.schemas;
-		if (!schemas) throw new Error('No schemas found in OpenAPI document');
-		const types = generateTypes(schemas);
+		const { data: openApi } = await axios.get<OpenAPIDocument>(openApiUrl)
+		const schemas = openApi.components?.schemas
+		if (!schemas) throw new Error('No schemas found in OpenAPI document')
+		const types = generateTypes(schemas)
 		// Generate Functions
-		const { paths } = openApi;
-		if (!paths) throw new Error('No paths found in OpenAPI document');
-		const code = generateFunctions(paths, baseURL); // TODO baseURL should not be set here, but should be instatiated in runtime somehow
-		return { types, code };
+		const { paths } = openApi
+		if (!paths) throw new Error('No paths found in OpenAPI document')
+		const code = generateFunctions(paths, baseURL) // TODO baseURL should not be set here, but should be instatiated in runtime somehow
+		return { types, code }
 	} catch (error: any) {
-		throw new Error(error);
+		throw new Error(error)
 	}
-};
+}

package/src/openAPITools/openApiTypes.ts

@@ -1,70 +1,70 @@
 export interface OpenAPIDocument {
-  openapi: string;
-  info: InfoObject;
-  paths: PathsObject,
-  components?: ComponentsObject;
+	openapi: string
+	info: InfoObject
+	paths: PathsObject
+	components?: ComponentsObject
 }
 
-export type PathsObject = { [path: string]: PathItemObject };
+export interface PathsObject { [path: string]: PathItemObject }
 
 export interface InfoObject {
-  title: string;
-  version: string;
+	title: string
+	version: string
 }
 
 export interface PathItemObject {
-  get?: OperationObject;
-  put?: OperationObject;
-  post?: OperationObject;
-  delete?: OperationObject;
+	get?: OperationObject
+	put?: OperationObject
+	post?: OperationObject
+	delete?: OperationObject
 }
 
-export type SchemasObject = { [schema: string]: SchemaObject };
+export interface SchemasObject { [schema: string]: SchemaObject }
 
 export interface ComponentsObject {
-  schemas?: SchemasObject
+	schemas?: SchemasObject
 }
 
 export interface OperationObject {
-  summary?: string;
-  operationId?: string;
-  parameters?: ParameterObject[];
-  requestBody?: RequestBodyObject;
-  responses: ResponsesObject;
+	summary?: string
+	operationId?: string
+	parameters?: ParameterObject[]
+	requestBody?: RequestBodyObject
+	responses: ResponsesObject
 }
 
-export type ResponsesObject = { [statusCode: string]: ResponseObject };
+export interface ResponsesObject { [statusCode: string]: ResponseObject }
 
 export interface SchemaObject {
-  type?: string;
-  properties?: { [property: string]: SchemaObject };
-  items?: SchemaObject;
-  $ref?: string;
-  enum: string[];
-  anyOf?: SchemaObject[];
-  allOf?: SchemaObject[];
-  title?: string;
-  description?: string;
-  default: any
+	type?: string
+	properties?: { [property: string]: SchemaObject }
+	items?: SchemaObject
+	$ref?: string
+	enum: string[]
+	anyOf?: SchemaObject[]
+	allOf?: SchemaObject[]
+	title?: string
+	description?: string
+	default: any
 }
 
 export interface ParameterObject {
-  name: string;
-  in: string;
-  schema: SchemaObject;
-  required?: boolean;
+	name: string
+	in: string
+	schema: SchemaObject
+	required?: boolean
 }
 
 export interface RequestBodyObject {
-  description?: string;
-  content: { [mediaType: string]: MediaTypeObject };
+	description?: string
+	content: { [mediaType: string]: MediaTypeObject }
 }
 
 export interface ResponseObject {
-  description: string;
-  content?: { [mediaType: string]: MediaTypeObject };
+	description: string
+	content?: { [mediaType: string]: MediaTypeObject }
 }
 
 export interface MediaTypeObject {
-  schema?: SchemaObject;
+	schema?: SchemaObject
 }

package/src/openAPITools/typeGenerator.ts

@@ -1,17 +1,19 @@
-import { formatType, formatVarType } from './utils';
-import type { SchemasObject } from './openApiTypes';
+import { formatType, formatVarType } from './utils'
+import type { SchemasObject } from './openApiTypes'
 
-export const generateTypes = (schemas: SchemasObject): string => Object.entries(schemas).map(([typeName, schema]) => {
-	typeName = formatType(typeName);
-	if (schema?.enum) {
-		return `export type ${typeName} = ${schema.enum.map((item: string) => `'${item}'`).join(' | ')};\n`;
-	}
-	if (!schema?.properties) return '';
+export function generateTypes(schemas: SchemasObject): string {
+	return Object.entries(schemas).map(([typeName, schema]) => {
+		typeName = formatType(typeName)
+		if (schema.enum) {
+			return `export type ${typeName} = ${schema.enum.map((item: string) => `'${item}'`).join(' | ')};\n`
+		}
+		if (!schema.properties) return ''
 
-	const properties = Object.entries(schema.properties).map(([key, value]) => {
-		const varType = formatVarType(key, value);
-		return `\t\t${varType}`;
-	}).join(';\n ');
+		const properties = Object.entries(schema.properties).map(([key, value]) => {
+			const varType = formatVarType(key, value)
+			return `\t\t${varType}`
+		}).join(';\n ')
 
-	return `export type ${typeName} = {\n ${properties};\n };\n`;
-}).join('\n');
+		return `export type ${typeName} = {\n ${properties};\n };\n`
+	}).join('\n')
+}