@bagelink/sdk 0.0.216 → 0.0.221

package/dist/index.cjs

@@ -1,10 +1,287 @@
 'use strict';
 
-const ax = require('axios');
+const axios$1 = require('axios');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
-const ax__default = /*#__PURE__*/_interopDefaultCompat(ax);
+const axios__default = /*#__PURE__*/_interopDefaultCompat(axios$1);
+
+const resolveReference = (ref) => {
+  const t = ref.split("/").pop() || "any";
+  return t;
+};
+const schemaToType = (schema) => {
+  if (!schema)
+    return "any";
+  if (schema.anyOf)
+    return schema.anyOf.map((s) => schemaToType(s)).filter((p) => p !== "any").join(" | ");
+  if (schema.allOf)
+    return schema.allOf.map((s) => schemaToType(s)).filter((p) => p !== "any").join(" & ");
+  if (schema.$ref)
+    return resolveReference(schema.$ref);
+  switch (schema.type) {
+    case "object":
+      return "Record<string, any>";
+    case "string":
+      return "string";
+    case "integer":
+      return "number";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "array":
+      return `${schemaToType(schema.items)}[]`;
+    case "null":
+      return "null";
+    default:
+      return "any";
+  }
+};
+const toCamelCase = (str) => str?.replace(/[-_\s]+(.)?/g, (_, c) => c?.toUpperCase() || "").replace(/^./, (str2) => str2.toLowerCase()) || str;
+const toPascalCase = (str) => str?.replace(/[-_\s]+(.)?/g, (_, c) => c?.toUpperCase() || "").replace(/^./, (str2) => str2.toUpperCase()) || str;
+const isOptional = (schema) => {
+  const type = schemaToType(schema);
+  return type?.split(/\s+\|\s+/).includes("null");
+};
+const cleanNulls = (str) => str.split(" | ").filter((t) => t !== "null").join(" | ");
+function formatVarType(varName, schema, required = false, defaultValue = null) {
+  let type = schemaToType(schema);
+  const optionalStr = required || isOptional(schema) ? "?" : "";
+  type = cleanNulls(type);
+  let defaultStr = defaultValue ? ` = ${defaultValue}` : "";
+  if (defaultStr && type === "string")
+    defaultStr = ` = '${defaultValue}'`;
+  else if (defaultValue && (typeof defaultValue === "object" || defaultValue === "{}"))
+    defaultStr = " = {}";
+  return `${varName}${optionalStr}: ${type}${defaultStr}`;
+}
+function cleanPath(path) {
+  return path.split("/").filter((p) => p && !p.match(/\{|\}/)).join("/");
+}
+
+const generateTypes = (schemas) => Object.entries(schemas).map(([typeName, schema]) => {
+  if (schema?.enum) {
+    return `export type ${typeName} = ${schema.enum.map((item) => `'${item}'`).join(" | ")};
+`;
+  }
+  if (!schema?.properties)
+    return "";
+  const properties = Object.entries(schema.properties).map(([key, value]) => {
+    const varType = formatVarType(key, value);
+    return `		${varType}`;
+  }).join(";\n ");
+  return `export type ${typeName} = {
+ ${properties};
+ };
+`;
+}).join("\n");
+
+const allTypes = [];
+function collectTypeForImportStatement(typeName) {
+  typeName = typeName.trim().replace("[]", "");
+  if (typeName.includes("|")) {
+    typeName.split("|").forEach(
+      (singleType) => collectTypeForImportStatement(singleType)
+    );
+    return;
+  }
+  const primitiveTypes = ["string", "number", "boolean", "null", "void", "any", "Record<string, any>"];
+  const isPrimitive = primitiveTypes.includes(typeName);
+  if (!typeName || isPrimitive)
+    return;
+  if (!allTypes.includes(typeName))
+    allTypes.push(typeName);
+}
+function getResponseType(response) {
+  const mediaTypeObject = response.content?.["application/json"];
+  if (!mediaTypeObject || !mediaTypeObject.schema)
+    return null;
+  const responseType = schemaToType(mediaTypeObject.schema);
+  collectTypeForImportStatement(responseType);
+  return responseType;
+}
+function generateResponseType(responses) {
+  if (!responses)
+    return "";
+  const types = [];
+  for (const [statusCode, response] of Object.entries(responses)) {
+    if (statusCode.startsWith("2")) {
+      const responseType = getResponseType(response);
+      if (responseType && responseType !== "any") {
+        types.push(responseType);
+      }
+    }
+  }
+  return types?.join(" | ");
+}
+function generateAxiosFunction(method, formattedPath, allParams, responseTypeStr, parameters, requestBodyPayload) {
+  let axiosFunction = `async (${allParams})${responseTypeStr} => axios.${method}(`;
+  const paramStr = parameters?.config?.params ? `, { params: {${parameters.config.params}} }` : "";
+  if (["get", "delete"].includes(method)) {
+    axiosFunction += `${formattedPath}${paramStr}`;
+  } else if (["post", "put", "patch"].includes(method)) {
+    const bodyVar = requestBodyPayload ? `, ${requestBodyPayload}` : "";
+    axiosFunction += `${formattedPath}${bodyVar}${paramStr}`;
+  }
+  axiosFunction += ")";
+  return axiosFunction;
+}
+const pathParamRegex = /\{([^}]+)\}/g;
+const getParamsFromPath = (path) => {
+  const params = path.match(pathParamRegex)?.map((p) => p.slice(1, -1));
+  return params;
+};
+function formatPathWithParams(path) {
+  const params = getParamsFromPath(path);
+  const formattedPath = params ? `\`${path.replace(pathParamRegex, (v) => `$${toCamelCase(v)}`)}\`` : `'${path}'`;
+  return formattedPath;
+}
+function generateRequestBody(requestBody) {
+  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 };
+}
+function combineAllParams(parameters, requestBodyParam) {
+  let allParamsArray = [];
+  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));
+  return allParamsArray.join(", ");
+}
+function generateFunctionParameters(params) {
+  if (!params || params.length === 0)
+    return {};
+  const functionParams = [];
+  const paramList = [];
+  for (const param of params) {
+    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);
+    }
+    if (param.in === "query" || param.in === "header") {
+      if (paramName === varName)
+        paramList.push(paramName);
+      else
+        paramList.push(`'${paramName}': ${varName}`);
+    }
+  }
+  const paramsString = functionParams.join(", ");
+  const config = {};
+  if (paramList.length > 0)
+    config.params = paramList.join(", ");
+  return { params: paramsString, config };
+}
+function generateFunctionForOperation(method, path, operation) {
+  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);
+function fileTemplate(tsString, typeForImport, baseURL) {
+  const templateCode = `import axios, { type AxiosResponse } from 'axios';
+	import type {${typeForImport.join(", ")}} from './types.d';
+	
+	axios.defaults.baseURL = ${baseURL};
+	
+	${tsString}`;
+  const doubleQuoteRegex = /"([^"]+)":/g;
+  return templateCode.replace(doubleQuoteRegex, "$1:");
+}
+const functionsInventory = {};
+const pathOperations = [];
+const hasConflict = (path, method) => {
+  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;
+};
+const createFunctionPlaceholder = (path, method, operation) => {
+  const funcID = generateRandomString();
+  functionsInventory[funcID] = generateFunctionForOperation(method, path, operation);
+  return funcID;
+};
+function handlePathSegment(path, operation, existingObj = null) {
+  const methods = Object.keys(operation);
+  const obj = {};
+  for (const method of methods) {
+    let functionName = method.toLowerCase();
+    if (hasConflict(path, method)) {
+      const params = getParamsFromPath(path);
+      functionName += params ? `By${toPascalCase(params?.pop() || "")}` : "All";
+    }
+    obj[functionName] = createFunctionPlaceholder(path, method, operation[method]);
+  }
+  return { ...obj, ...existingObj };
+}
+function generateFunctions(paths, baseURL) {
+  let tsString = "";
+  const body = {};
+  const allPathsClean = Object.keys(paths).map(cleanPath);
+  for (const [path, operation] of Object.entries(paths)) {
+    const splitPath = path.split("/").filter((p) => p && !p.match(/\{|\}/));
+    splitPath.reduce((acc, key, index, array) => {
+      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) {
+        const method = methods[0];
+        const opp = { ...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);
+  }
+  for (const [parent, object] of Object.entries(body)) {
+    tsString += `export const ${parent} = ${JSON.stringify(object, null, 2)};
+`;
+  }
+  Object.entries(functionsInventory).forEach(([key, value]) => {
+    tsString = tsString.replace(`"${key}"`, value);
+  });
+  tsString = fileTemplate(tsString, allTypes, baseURL);
+  return tsString;
+}
+
+const index = async (openApiUrl, baseURL) => {
+  try {
+    const { data: openApi } = await axios__default.get(openApiUrl);
+    const schemas = openApi.components?.schemas;
+    if (!schemas)
+      throw new Error("No schemas found in OpenAPI document");
+    const types = generateTypes(schemas);
+    const { paths } = openApi;
+    if (!paths)
+      throw new Error("No paths found in OpenAPI document");
+    const code = generateFunctions(paths, baseURL);
+    return { types, code };
+  } catch (error) {
+    throw new Error(error);
+  }
+};
 
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -12,7 +289,7 @@ var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
-const axios = ax__default.create({
+const axios = axios__default.create({
   // withCredentials to true to send cookies with requests
   withCredentials: true
 });
@@ -234,3 +511,4 @@ class Bagel {
 }
 
 exports.Bagel = Bagel;
+exports.openAPI = index;

package/dist/index.d.cts

@@ -1,5 +1,12 @@
+type OpenAPIResponse = {
+    types: string;
+    code: string;
+};
+declare const _default: (openApiUrl: string, baseURL: string) => Promise<OpenAPIResponse>;
+
 type Tables = '';
 type TableToTypeMapping = Record<Tables, any>;
+
 interface User {
     id: string;
     first_name?: string;
@@ -58,4 +65,4 @@ declare class Bagel {
     uploadFile(file: File, options?: UploadOptions): Promise<any>;
 }
 
-export { Bagel, type TableToTypeMapping, type Tables, type User };
+export { Bagel, type TableToTypeMapping, type Tables, type User, _default as openAPI };

package/dist/index.d.mts

@@ -1,5 +1,12 @@
+type OpenAPIResponse = {
+    types: string;
+    code: string;
+};
+declare const _default: (openApiUrl: string, baseURL: string) => Promise<OpenAPIResponse>;
+
 type Tables = '';
 type TableToTypeMapping = Record<Tables, any>;
+
 interface User {
     id: string;
     first_name?: string;
@@ -58,4 +65,4 @@ declare class Bagel {
     uploadFile(file: File, options?: UploadOptions): Promise<any>;
 }
 
-export { Bagel, type TableToTypeMapping, type Tables, type User };
+export { Bagel, type TableToTypeMapping, type Tables, type User, _default as openAPI };

package/dist/index.d.ts

@@ -1,5 +1,12 @@
+type OpenAPIResponse = {
+    types: string;
+    code: string;
+};
+declare const _default: (openApiUrl: string, baseURL: string) => Promise<OpenAPIResponse>;
+
 type Tables = '';
 type TableToTypeMapping = Record<Tables, any>;
+
 interface User {
     id: string;
     first_name?: string;
@@ -58,4 +65,4 @@ declare class Bagel {
     uploadFile(file: File, options?: UploadOptions): Promise<any>;
 }
 
-export { Bagel, type TableToTypeMapping, type Tables, type User };
+export { Bagel, type TableToTypeMapping, type Tables, type User, _default as openAPI };

package/dist/index.mjs

@@ -1,4 +1,281 @@
-import ax from 'axios';
+import axios$1 from 'axios';
+
+const resolveReference = (ref) => {
+  const t = ref.split("/").pop() || "any";
+  return t;
+};
+const schemaToType = (schema) => {
+  if (!schema)
+    return "any";
+  if (schema.anyOf)
+    return schema.anyOf.map((s) => schemaToType(s)).filter((p) => p !== "any").join(" | ");
+  if (schema.allOf)
+    return schema.allOf.map((s) => schemaToType(s)).filter((p) => p !== "any").join(" & ");
+  if (schema.$ref)
+    return resolveReference(schema.$ref);
+  switch (schema.type) {
+    case "object":
+      return "Record<string, any>";
+    case "string":
+      return "string";
+    case "integer":
+      return "number";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "array":
+      return `${schemaToType(schema.items)}[]`;
+    case "null":
+      return "null";
+    default:
+      return "any";
+  }
+};
+const toCamelCase = (str) => str?.replace(/[-_\s]+(.)?/g, (_, c) => c?.toUpperCase() || "").replace(/^./, (str2) => str2.toLowerCase()) || str;
+const toPascalCase = (str) => str?.replace(/[-_\s]+(.)?/g, (_, c) => c?.toUpperCase() || "").replace(/^./, (str2) => str2.toUpperCase()) || str;
+const isOptional = (schema) => {
+  const type = schemaToType(schema);
+  return type?.split(/\s+\|\s+/).includes("null");
+};
+const cleanNulls = (str) => str.split(" | ").filter((t) => t !== "null").join(" | ");
+function formatVarType(varName, schema, required = false, defaultValue = null) {
+  let type = schemaToType(schema);
+  const optionalStr = required || isOptional(schema) ? "?" : "";
+  type = cleanNulls(type);
+  let defaultStr = defaultValue ? ` = ${defaultValue}` : "";
+  if (defaultStr && type === "string")
+    defaultStr = ` = '${defaultValue}'`;
+  else if (defaultValue && (typeof defaultValue === "object" || defaultValue === "{}"))
+    defaultStr = " = {}";
+  return `${varName}${optionalStr}: ${type}${defaultStr}`;
+}
+function cleanPath(path) {
+  return path.split("/").filter((p) => p && !p.match(/\{|\}/)).join("/");
+}
+
+const generateTypes = (schemas) => Object.entries(schemas).map(([typeName, schema]) => {
+  if (schema?.enum) {
+    return `export type ${typeName} = ${schema.enum.map((item) => `'${item}'`).join(" | ")};
+`;
+  }
+  if (!schema?.properties)
+    return "";
+  const properties = Object.entries(schema.properties).map(([key, value]) => {
+    const varType = formatVarType(key, value);
+    return `		${varType}`;
+  }).join(";\n ");
+  return `export type ${typeName} = {
+ ${properties};
+ };
+`;
+}).join("\n");
+
+const allTypes = [];
+function collectTypeForImportStatement(typeName) {
+  typeName = typeName.trim().replace("[]", "");
+  if (typeName.includes("|")) {
+    typeName.split("|").forEach(
+      (singleType) => collectTypeForImportStatement(singleType)
+    );
+    return;
+  }
+  const primitiveTypes = ["string", "number", "boolean", "null", "void", "any", "Record<string, any>"];
+  const isPrimitive = primitiveTypes.includes(typeName);
+  if (!typeName || isPrimitive)
+    return;
+  if (!allTypes.includes(typeName))
+    allTypes.push(typeName);
+}
+function getResponseType(response) {
+  const mediaTypeObject = response.content?.["application/json"];
+  if (!mediaTypeObject || !mediaTypeObject.schema)
+    return null;
+  const responseType = schemaToType(mediaTypeObject.schema);
+  collectTypeForImportStatement(responseType);
+  return responseType;
+}
+function generateResponseType(responses) {
+  if (!responses)
+    return "";
+  const types = [];
+  for (const [statusCode, response] of Object.entries(responses)) {
+    if (statusCode.startsWith("2")) {
+      const responseType = getResponseType(response);
+      if (responseType && responseType !== "any") {
+        types.push(responseType);
+      }
+    }
+  }
+  return types?.join(" | ");
+}
+function generateAxiosFunction(method, formattedPath, allParams, responseTypeStr, parameters, requestBodyPayload) {
+  let axiosFunction = `async (${allParams})${responseTypeStr} => axios.${method}(`;
+  const paramStr = parameters?.config?.params ? `, { params: {${parameters.config.params}} }` : "";
+  if (["get", "delete"].includes(method)) {
+    axiosFunction += `${formattedPath}${paramStr}`;
+  } else if (["post", "put", "patch"].includes(method)) {
+    const bodyVar = requestBodyPayload ? `, ${requestBodyPayload}` : "";
+    axiosFunction += `${formattedPath}${bodyVar}${paramStr}`;
+  }
+  axiosFunction += ")";
+  return axiosFunction;
+}
+const pathParamRegex = /\{([^}]+)\}/g;
+const getParamsFromPath = (path) => {
+  const params = path.match(pathParamRegex)?.map((p) => p.slice(1, -1));
+  return params;
+};
+function formatPathWithParams(path) {
+  const params = getParamsFromPath(path);
+  const formattedPath = params ? `\`${path.replace(pathParamRegex, (v) => `$${toCamelCase(v)}`)}\`` : `'${path}'`;
+  return formattedPath;
+}
+function generateRequestBody(requestBody) {
+  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 };
+}
+function combineAllParams(parameters, requestBodyParam) {
+  let allParamsArray = [];
+  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));
+  return allParamsArray.join(", ");
+}
+function generateFunctionParameters(params) {
+  if (!params || params.length === 0)
+    return {};
+  const functionParams = [];
+  const paramList = [];
+  for (const param of params) {
+    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);
+    }
+    if (param.in === "query" || param.in === "header") {
+      if (paramName === varName)
+        paramList.push(paramName);
+      else
+        paramList.push(`'${paramName}': ${varName}`);
+    }
+  }
+  const paramsString = functionParams.join(", ");
+  const config = {};
+  if (paramList.length > 0)
+    config.params = paramList.join(", ");
+  return { params: paramsString, config };
+}
+function generateFunctionForOperation(method, path, operation) {
+  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);
+function fileTemplate(tsString, typeForImport, baseURL) {
+  const templateCode = `import axios, { type AxiosResponse } from 'axios';
+	import type {${typeForImport.join(", ")}} from './types.d';
+	
+	axios.defaults.baseURL = ${baseURL};
+	
+	${tsString}`;
+  const doubleQuoteRegex = /"([^"]+)":/g;
+  return templateCode.replace(doubleQuoteRegex, "$1:");
+}
+const functionsInventory = {};
+const pathOperations = [];
+const hasConflict = (path, method) => {
+  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;
+};
+const createFunctionPlaceholder = (path, method, operation) => {
+  const funcID = generateRandomString();
+  functionsInventory[funcID] = generateFunctionForOperation(method, path, operation);
+  return funcID;
+};
+function handlePathSegment(path, operation, existingObj = null) {
+  const methods = Object.keys(operation);
+  const obj = {};
+  for (const method of methods) {
+    let functionName = method.toLowerCase();
+    if (hasConflict(path, method)) {
+      const params = getParamsFromPath(path);
+      functionName += params ? `By${toPascalCase(params?.pop() || "")}` : "All";
+    }
+    obj[functionName] = createFunctionPlaceholder(path, method, operation[method]);
+  }
+  return { ...obj, ...existingObj };
+}
+function generateFunctions(paths, baseURL) {
+  let tsString = "";
+  const body = {};
+  const allPathsClean = Object.keys(paths).map(cleanPath);
+  for (const [path, operation] of Object.entries(paths)) {
+    const splitPath = path.split("/").filter((p) => p && !p.match(/\{|\}/));
+    splitPath.reduce((acc, key, index, array) => {
+      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) {
+        const method = methods[0];
+        const opp = { ...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);
+  }
+  for (const [parent, object] of Object.entries(body)) {
+    tsString += `export const ${parent} = ${JSON.stringify(object, null, 2)};
+`;
+  }
+  Object.entries(functionsInventory).forEach(([key, value]) => {
+    tsString = tsString.replace(`"${key}"`, value);
+  });
+  tsString = fileTemplate(tsString, allTypes, baseURL);
+  return tsString;
+}
+
+const index = async (openApiUrl, baseURL) => {
+  try {
+    const { data: openApi } = await axios$1.get(openApiUrl);
+    const schemas = openApi.components?.schemas;
+    if (!schemas)
+      throw new Error("No schemas found in OpenAPI document");
+    const types = generateTypes(schemas);
+    const { paths } = openApi;
+    if (!paths)
+      throw new Error("No paths found in OpenAPI document");
+    const code = generateFunctions(paths, baseURL);
+    return { types, code };
+  } catch (error) {
+    throw new Error(error);
+  }
+};
 
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -6,7 +283,7 @@ var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
-const axios = ax.create({
+const axios = axios$1.create({
   // withCredentials to true to send cookies with requests
   withCredentials: true
 });
@@ -227,4 +504,4 @@ class Bagel {
   }
 }
 
-export { Bagel };
+export { Bagel, index as openAPI };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bagelink/sdk",
   "type": "module",
-  "version": "0.0.216",
+  "version": "0.0.221",
   "description": "Bagel core sdk packages",
   "author": {
     "name": "Neveh Allon",

package/src/index.ts

@@ -1,8 +1,11 @@
 import ax from 'axios';
 
+import openAPI from './openAPITools';
+
 export type Tables = '';
 export type TableToTypeMapping = Record<Tables, any>;
 
+export { openAPI };
 export interface User {
   id: string
   first_name?: string

package/src/openAPITools/functionGenerator.ts

@@ -0,0 +1,245 @@
+import type {
+	OperationObject, ParameterObject, PathsObject, RequestBodyObject, ResponseObject, ResponsesObject,
+} from './openApiTypes';
+import {
+	cleanPath,
+	formatVarType, schemaToType, toCamelCase, toPascalCase,
+} from './utils';
+
+const allTypes: string[] = [];
+
+function collectTypeForImportStatement(typeName: string) {
+	typeName = typeName.trim().replace('[]', '');
+	if (typeName.includes('|')) {
+		typeName
+			.split('|')
+			.forEach(
+				(singleType) => collectTypeForImportStatement(singleType),
+			);
+		return;
+	}
+	const primitiveTypes = ['string', 'number', 'boolean', 'null', 'void', 'any', 'Record<string, any>'];
+	const isPrimitive = primitiveTypes.includes(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;
+}
+
+function generateResponseType(responses?: ResponsesObject): string {
+	if (!responses) return '';
+	const types: string[] = [];
+
+	for (const [statusCode, response] of Object.entries(responses)) {
+		if (statusCode.startsWith('2')) {
+			const responseType = getResponseType(response);
+			if (responseType && responseType !== 'any') {
+				types.push(responseType);
+			}
+		}
+	}
+	return types?.join(' | ');
+}
+
+/**
+ * Generates the string representation of an Axios function call.
+ * @param method - The HTTP method (get, post, etc.).
+ * @param formattedPath - The API endpoint path, formatted with template literals for parameters.
+ * @param allParams - All parameters required for the function, formatted as a string.
+ * @param responseTypeStr - The expected response type for the function.
+ * @param parameters - Additional configuration parameters, if any.
+ * @returns A string representing the Axios function.
+ */
+function generateAxiosFunction(
+	method: string,
+	formattedPath: string,
+	allParams: string,
+	responseTypeStr: string,
+	parameters: any,
+	requestBodyPayload: string,
+): string {
+	let axiosFunction = `async (${allParams})${responseTypeStr} => axios.${method}(`;
+	// Different handling based on the HTTP method
+	const paramStr = parameters?.config?.params ? `, { params: {${parameters.config.params}} }` : '';
+	if (['get', 'delete'].includes(method)) {
+		axiosFunction += `${formattedPath}${paramStr}`;
+	} else if (['post', 'put', 'patch'].includes(method)) {
+		const bodyVar = requestBodyPayload ? `, ${requestBodyPayload}` : '';
+
+		axiosFunction += `${formattedPath}${bodyVar}${paramStr}`;
+	}
+	axiosFunction += ')';
+	return axiosFunction;
+}
+
+const pathParamRegex = /\{([^}]+)\}/g;
+const 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;
+}
+
+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 };
+}
+
+/**
+ * Combines and formats function parameters and request body parameters into a single parameter string.
+ * @param parameters - The parameters derived from the OpenAPI specification.
+ * @param requestBodyParam - The parameter representing the request body.
+ * @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());
+
+	allParamsArray = allParamsArray
+		.filter((p) => p).sort((a, b) => (a.includes('?') ? 1 : -1) - (b.includes('?') ? 1 : -1));
+
+	return allParamsArray.join(', ');
+}
+
+function generateFunctionParameters(params?: ParameterObject[]) {
+	if (!params || params.length === 0) return {};
+
+	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';
+		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);
+		}
+		if (param.in === 'query' || param.in === 'header') {
+			if (paramName === varName) paramList.push(paramName);
+			else paramList.push(`'${paramName}': ${varName}`);
+		}
+	}
+
+	const paramsString = functionParams.join(', ');
+	const config: { params?: string } = {};
+
+	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);
+}
+
+const generateRandomString = () => Math.random().toString(36).substring(7);
+
+function fileTemplate(tsString: string, typeForImport: string[], baseURL: string) {
+	const templateCode = (
+		`import axios, { type AxiosResponse } from 'axios';
+	import type {${typeForImport.join(', ')}} from './types.d';
+	
+	axios.defaults.baseURL = ${baseURL};
+	
+	${tsString}`
+	);
+	const doubleQuoteRegex = /"([^"]+)":/g;
+	return templateCode.replace(doubleQuoteRegex, '$1:');
+}
+
+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;
+};
+
+// 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 handlePathSegment(
+	path: string,
+	operation: any,
+	existingObj: Record<string, any> | null = null,
+) {
+	const methods = Object.keys(operation);
+	const obj: Record<string, any> = {};
+	for (const method of methods) {
+		let functionName = method.toLowerCase();
+		if (hasConflict(path, method)) {
+			const params: string[] | undefined = getParamsFromPath(path);
+			functionName += (params ? `By${toPascalCase(params?.pop() || '')}` : 'All');
+		}
+		obj[functionName] = createFunctionPlaceholder(path, method, operation[method]);
+	}
+
+	return { ...obj, ...existingObj };
+}
+
+export function generateFunctions(paths: PathsObject, baseURL: string) {
+	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(/\{|\}/));
+		splitPath.reduce((acc, key: string, index: number, array: string[]) => {
+			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
+			) {
+				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);
+	}
+	for (const [parent, object] of Object.entries(body)) {
+		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;
+}

package/src/openAPITools/index.ts

@@ -0,0 +1,25 @@
+import axios from 'axios';
+import type { OpenAPIDocument } from './openApiTypes';
+import { generateTypes } from './typeGenerator';
+import { generateFunctions } from './functionGenerator';
+
+type 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);
+		// Generate Functions
+		const { paths } = openApi;
+		if (!paths) throw new Error('No paths found in OpenAPI document');
+		const code = generateFunctions(paths, baseURL);
+		return { types, code };
+	} catch (error: any) {
+		throw new Error(error);
+	}
+};

package/src/openAPITools/openApiTypes.ts

@@ -0,0 +1,70 @@
+export interface OpenAPIDocument {
+  openapi: string;
+  info: InfoObject;
+  paths: PathsObject,
+  components?: ComponentsObject;
+}
+
+export type PathsObject = { [path: string]: PathItemObject };
+
+export interface InfoObject {
+  title: string;
+  version: string;
+}
+
+export interface PathItemObject {
+  get?: OperationObject;
+  put?: OperationObject;
+  post?: OperationObject;
+  delete?: OperationObject;
+}
+
+export type SchemasObject = { [schema: string]: SchemaObject };
+
+export interface ComponentsObject {
+  schemas?: SchemasObject
+}
+
+export interface OperationObject {
+  summary?: string;
+  operationId?: string;
+  parameters?: ParameterObject[];
+  requestBody?: RequestBodyObject;
+  responses: ResponsesObject;
+}
+
+export type 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
+}
+
+export interface ParameterObject {
+  name: string;
+  in: string;
+  schema: SchemaObject;
+  required?: boolean;
+}
+
+export interface RequestBodyObject {
+  description?: string;
+  content: { [mediaType: string]: MediaTypeObject };
+}
+
+export interface ResponseObject {
+  description: string;
+  content?: { [mediaType: string]: MediaTypeObject };
+}
+
+export interface MediaTypeObject {
+  schema?: SchemaObject;
+}

package/src/openAPITools/typeGenerator.ts

@@ -0,0 +1,16 @@
+import { formatVarType } from './utils';
+import type { SchemasObject } from './openApiTypes';
+
+export const generateTypes = (schemas: SchemasObject): string => Object.entries(schemas).map(([typeName, schema]) => {
+	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 ');
+
+	return `export type ${typeName} = {\n ${properties};\n };\n`;
+}).join('\n');

package/src/openAPITools/utils.ts

@@ -0,0 +1,56 @@
+import type { SchemaObject } from './openApiTypes';
+
+const resolveReference = (ref: string): string => {
+	const t = ref.split('/').pop() || 'any';
+	return t;
+};
+
+export const schemaToType = (schema?: SchemaObject): string => {
+	if (!schema) return 'any';
+	if (schema.anyOf) return schema.anyOf.map((s) => schemaToType(s)).filter((p) => p !== 'any').join(' | ');
+	if (schema.allOf) return schema.allOf.map((s) => schemaToType(s)).filter((p) => p !== 'any').join(' & ');
+	if (schema.$ref) return resolveReference(schema.$ref);
+	switch (schema.type) {
+	case 'object':
+		return 'Record<string, any>';
+	case 'string':
+		return 'string';
+	case 'integer':
+		return 'number';
+	case 'number':
+		return 'number';
+	case 'boolean':
+		return 'boolean';
+	case 'array':
+		return `${schemaToType(schema.items)}[]`;
+	case 'null':
+		return 'null';
+	default:
+		return 'any';
+	}
+};
+
+export const toCamelCase = (str?: string) => str?.replace(/[-_\s]+(.)?/g, (_, c) => c?.toUpperCase() || '').replace(/^./, (str) => str.toLowerCase()) || str;
+export const toPascalCase = (str?: string) => str?.replace(/[-_\s]+(.)?/g, (_, c) => c?.toUpperCase() || '').replace(/^./, (str) => str.toUpperCase()) || str;
+
+export const isOptional = (schema: SchemaObject) => {
+	/// / !schema?.required?.includes(schema.title || '')
+	const type = schemaToType(schema);
+	return type?.split(/\s+\|\s+/).includes('null');
+};
+
+export const cleanNulls = (str: string) => str.split(' | ').filter((t) => t !== 'null').join(' | ');
+
+export function formatVarType(varName: string, schema: any, required = false, defaultValue: any = null) {
+	let type = schemaToType(schema);
+	const optionalStr = required || isOptional(schema) ? '?' : '';
+	type = cleanNulls(type);
+	let defaultStr = defaultValue ? ` = ${defaultValue}` : '';
+	if (defaultStr && type === 'string') defaultStr = ` = '${defaultValue}'`;
+	else if (defaultValue && (typeof defaultValue === 'object' || defaultValue === '{}')) defaultStr = ' = {}';
+	return `${varName}${optionalStr}: ${type}${defaultStr}`;
+}
+
+export function cleanPath(path: string) {
+	return path.split('/').filter((p) => p && !p.match(/\{|\}/)).join('/');
+}