@bagelink/sdk 0.0.1121 → 0.0.1125

package/dist/index.cjs

@@ -6,31 +6,32 @@ function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'defau
 
 const axios__default = /*#__PURE__*/_interopDefaultCompat(axios$1);
 
-const toCamelCase = (str) => str?.replaceAll(/[-._\s]+(.)?/g, (_, c) => c?.toUpperCase() || "").replace(/^./, (str2) => str2.toLowerCase()) || str || "";
-const toPascalCase = (str) => str?.replaceAll(/[-_\s]+(.)?/g, (_, c) => c?.toUpperCase() || "").replace(/^./, (str2) => str2.toUpperCase()) || str || "";
+function toCamelCase(str) {
+  return str?.replaceAll(/[-._\s]+(.)?/g, (_, c) => c?.toUpperCase() || "").replace(/^./, (str2) => str2.toLowerCase()) || str || "";
+}
+function toPascalCase(str) {
+  return str?.replaceAll(/[-_\s]+(.)?/g, (_, c) => c?.toUpperCase() || "").replace(/^./, (str2) => str2.toUpperCase()) || str || "";
+}
 function formatType(typeName) {
-  typeName = typeName.replaceAll("-", "").replaceAll(/(post|put)$/gi, "").replaceAll(/^body_/gi, "");
+  typeName = typeName.replaceAll("-", "").replaceAll(/post|put$/gi, "").replaceAll(/^body_/gi, "");
   return toPascalCase(typeName);
 }
 function resolveReference(ref) {
   const t = ref.split("/").pop();
-  if (!t)
-    return "any";
+  if (!t) return "any";
   return formatType(t);
 }
 function schemaToType(schema) {
-  if (!schema)
-    return "any";
+  if (!schema) return "any";
   if (schema.anyOf) {
     let _t = schema.anyOf.map((s) => schemaToType(s)).filter((p) => p !== "any").join(" | ");
-    if (_t === "" || _t === "null")
-      _t = "any";
+    if (_t === "" || _t === "null") _t = "any";
     return _t;
   }
-  if (schema.allOf)
+  if (schema.allOf) {
     return schema.allOf.map((s) => schemaToType(s)).filter((p) => p !== "any").join(" & ");
-  if (schema.$ref)
-    return resolveReference(schema.$ref);
+  }
+  if (schema.$ref) return resolveReference(schema.$ref);
   switch (schema.type) {
     case "object":
       return "{ [key: string]: any }";
@@ -48,7 +49,7 @@ function schemaToType(schema) {
       return "undefined";
     case "null":
       return "null";
-    case void 0:
+    case undefined:
       return "any";
     default:
       console.log("Unknown type", schema.type);
@@ -60,10 +61,17 @@ function isOptional(schema) {
   const splitType = type.split(/\s+\|\s+/);
   const includesNull = splitType.includes("null");
   const includesUndefined = splitType.includes("undefined");
-  return includesNull || includesUndefined || schema.default !== void 0;
+  return includesNull || includesUndefined || schema.default !== undefined;
 }
-const cleanOptionals = (str) => str.split(" | ").filter((t) => t !== "null" && t !== "undefined").join(" | ");
-function formatVarType(varName, schema, required = false, defaultValue) {
+function cleanOptionals(str) {
+  return str.split(" | ").filter((t) => t !== "null" && t !== "undefined").join(" | ");
+}
+function formatVarType({
+  varName,
+  schema,
+  required = false,
+  defaultValue
+}) {
   let type = schemaToType(schema);
   type = cleanOptionals(type);
   let defaultStr = "";
@@ -74,9 +82,8 @@ function formatVarType(varName, schema, required = false, defaultValue) {
       defaultStr = ` = ${defaultValue}`;
     }
   }
-  let optionalStr = required || isOptional(schema) ? "?" : "";
-  if (defaultStr)
-    optionalStr = "";
+  let optionalStr = !required && isOptional(schema) ? "?" : "";
+  if (defaultStr) optionalStr = "";
   return `${varName}${optionalStr}: ${type}${defaultStr}`;
 }
 function cleanPath(path) {
@@ -84,35 +91,39 @@ function cleanPath(path) {
 }
 
 const allTypes = [];
-const primitiveTypes = ["string", "number", "boolean", "null", "void", "any", "Record<string, any>", "undefined", "{ [key: string]: any }"];
+const primitiveTypes = [
+  "string",
+  "number",
+  "boolean",
+  "null",
+  "void",
+  "any",
+  "Record<string, any>",
+  "undefined",
+  "{ [key: string]: any }"
+];
 function collectTypeForImportStatement(typeName) {
   typeName = typeName.trim().replace("[]", "");
   if (typeName.includes("|")) {
-    typeName.split("|").forEach(
-      (singleType) => {
-        collectTypeForImportStatement(singleType);
-      }
-    );
+    typeName.split("|").forEach((singleType) => {
+      collectTypeForImportStatement(singleType);
+    });
     return;
   }
   const isPrimitive = primitiveTypes.includes(typeName);
   typeName = formatType(typeName);
-  if (!typeName || isPrimitive)
-    return;
-  if (!allTypes.includes(typeName))
-    allTypes.push(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;
+  if (!mediaTypeObject || !mediaTypeObject.schema) return;
   const responseType = schemaToType(mediaTypeObject.schema);
   collectTypeForImportStatement(responseType);
   return responseType;
 }
 function generateResponseType(responses) {
-  if (!responses)
-    return "";
+  if (!responses) return "";
   const types = [];
   for (const [statusCode, response] of Object.entries(responses)) {
     if (statusCode.startsWith("2")) {
@@ -125,8 +136,7 @@ function generateResponseType(responses) {
   return types.join(" | ");
 }
 function generateAxiosFunction(method, formattedPath, allParams, responseTypeStr, parameters, requestBodyPayload) {
-  if (allParams === "undefined")
-    allParams = "";
+  if (allParams === "undefined") allParams = "";
   let axiosFunction = `async (${allParams})${responseTypeStr} => {`;
   if (requestBodyPayload === "formData") {
     const paramStr = parameters?.config?.params ? `params: {${parameters.config.params}}` : "";
@@ -175,21 +185,23 @@ function generateRequestBody(requestBody) {
   const requestBodyType = schemaToType(bodySchema);
   collectTypeForImportStatement(requestBodyType);
   const requestBodyPayload = toCamelCase(bodySchema.title) || toCamelCase(requestBodyType) || "requestBody";
-  const requestBodyParam = formatVarType(requestBodyPayload, bodySchema, bodySchema.default);
+  const requestBodyParam = formatVarType({
+    varName: requestBodyPayload,
+    schema: bodySchema,
+    defaultValue: bodySchema.default
+  });
   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());
+  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, isFileUpload = false) {
-  if (!params?.length)
-    return {};
+  if (!params?.length) return {};
   if (isFileUpload) {
     return {
       config: {
@@ -207,10 +219,19 @@ function generateFunctionParameters(params, isFileUpload = false) {
     const paramName = param.name;
     const varName = toCamelCase(param.name);
     if (param.in === "path" || param.in === "query" || param.in === "header") {
-      functionParams.push(formatVarType(varName, param.schema, param.required, param.schema.default));
+      functionParams.push(
+        formatVarType({
+          varName,
+          schema: param.schema,
+          required: param.required,
+          defaultValue: param.schema.default
+        })
+      );
     }
     if (param.in === "query" || param.in === "header") {
-      paramList.push(paramName === varName ? paramName : `'${paramName}': ${varName}`);
+      paramList.push(
+        paramName === varName ? paramName : `'${paramName}': ${varName}`
+      );
     }
   }
   return {
@@ -219,11 +240,15 @@ function generateFunctionParameters(params, isFileUpload = false) {
   };
 }
 function generateFunctionForOperation(method, path, operation) {
-  if (!operation)
-    return "";
+  if (!operation) return "";
   const isFileUpload = operation.requestBody?.content["multipart/form-data"]?.schema?.$ref?.includes("Body_upload_files");
-  const parameters = generateFunctionParameters(operation.parameters, isFileUpload);
-  const { requestBodyParam, requestBodyPayload } = generateRequestBody(operation.requestBody);
+  const parameters = generateFunctionParameters(
+    operation.parameters,
+    isFileUpload
+  );
+  const { requestBodyParam, requestBodyPayload } = generateRequestBody(
+    operation.requestBody
+  );
   const allParams = isFileUpload ? "file: File, options?: UploadOptions & { dirPath?: string, tags?: string[] }" : combineAllParams(parameters, requestBodyParam);
   const responseType = generateResponseType(operation.responses);
   const responseTypeStr = responseType ? `: Promise<AxiosResponse<${responseType}>>` : "";
@@ -241,13 +266,13 @@ function fileTemplate(tsString, typeForImport, baseURL) {
   const templateCode = `import ax from 'axios';
 		 import type { AxiosResponse } from 'axios';
 		 import type {${typeForImport.join(", ")}} from './types.d';
-		
+
 	interface UploadOptions {
 		onUploadProgress?: (progressEvent: any) => void
 		dirPath?: string
 		tags?: string[]
 	}
-	
+
 	export const axios = ax.create({baseURL:${baseURL}});
 	${tsString}`;
   const doubleQuoteRegex = /"([^"]+)":/g;
@@ -257,13 +282,19 @@ const functionsInventory = {};
 const pathOperations = [];
 function hasConflict(path, method) {
   const cleanPathName = path.split("/").filter((p) => p && !/\{|\}/.test(p)).join("/");
-  const matchingPaths = pathOperations.filter((p) => p.path === cleanPathName && p.method === method);
+  const matchingPaths = pathOperations.filter(
+    (p) => p.path === cleanPathName && p.method === method
+  );
   pathOperations.push({ path: cleanPathName, method });
   return matchingPaths.length > 0;
 }
 function createFunctionPlaceholder(path, method, operation) {
   const funcID = generateRandomString();
-  functionsInventory[funcID] = generateFunctionForOperation(method, path, operation);
+  functionsInventory[funcID] = generateFunctionForOperation(
+    method,
+    path,
+    operation
+  );
   return funcID;
 }
 function handlePathSegment(path, operation, existingObj = {}) {
@@ -275,7 +306,11 @@ function handlePathSegment(path, operation, existingObj = {}) {
       const params = 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 };
 }
@@ -287,8 +322,7 @@ function generateFunctions(paths, baseUrl) {
     const splitPath = path.split("/").filter((p) => p && !/\{|\}/.test(p));
     splitPath.reduce((acc, key, index, array) => {
       const objFuncKey = toCamelCase(key);
-      if (!objFuncKey)
-        return acc;
+      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];
@@ -303,7 +337,7 @@ function generateFunctions(paths, baseUrl) {
     }, body);
   }
   for (const [parent, object] of Object.entries(body)) {
-    tsString += `export const ${parent} = ${JSON.stringify(object, void 0, 2)};
+    tsString += `export const ${parent} = ${JSON.stringify(object, undefined, 2)};
 `;
   }
   Object.entries(functionsInventory).forEach(([key, value]) => {
@@ -320,10 +354,9 @@ function generateTypes(schemas) {
       return `export type ${typeName} = ${schema.enum.map((item) => `'${item}'`).join(" | ")};
 `;
     }
-    if (!schema.properties)
-      return "";
+    if (!schema.properties) return "";
     const properties = Object.entries(schema.properties).map(([key, value]) => {
-      const varType = formatVarType(key, value);
+      const varType = formatVarType({ varName: key, schema: value });
       return `		${varType}`;
     }).join(";\n ");
     return `export type ${typeName} = {
@@ -338,12 +371,10 @@ const index = async (openApiUrl, baseUrl) => {
   try {
     const { data: openApi } = await axios__default.get(openApiUrl, { headers: basicAuthHeader });
     const schemas = openApi.components?.schemas;
-    if (!schemas)
-      throw new Error("No schemas found in OpenAPI document");
+    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");
+    if (!paths) throw new Error("No paths found in OpenAPI document");
     const code = generateFunctions(paths, baseUrl);
     return { types, code };
   } catch (error) {
@@ -351,28 +382,21 @@ const index = async (openApiUrl, baseUrl) => {
   }
 };
 
-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;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
 const axios = axios__default.create({
   withCredentials: true
 });
 class DataRequest {
+  data_table;
+  bagel;
+  itemID;
+  _filter = {};
   constructor(table, bagel) {
-    __publicField(this, "data_table");
-    __publicField(this, "bagel");
-    __publicField(this, "itemID");
-    __publicField(this, "_filter", {});
     this.data_table = table;
     this.bagel = bagel;
     this.itemID = "";
   }
   async post(item) {
-    if (!this.data_table)
-      throw new Error("Data table not set");
+    if (!this.data_table) throw new Error("Data table not set");
     const { data } = await axios.post(`/data/${this.data_table}`, item);
     return data;
   }
@@ -381,8 +405,7 @@ class DataRequest {
     return this;
   }
   async get() {
-    if (!this.data_table)
-      throw new Error("Data table not set");
+    if (!this.data_table) throw new Error("Data table not set");
     const filterStr = Object.keys(this._filter).length > 0 ? `?filter={${Object.entries(this._filter).map(([k, v]) => `${k}:${v}`).join(",")}}` : "";
     const url = `/data/${this.data_table}${this.itemID ? `/${this.itemID}` : ""}${filterStr}`;
     try {
@@ -391,7 +414,7 @@ class DataRequest {
     } catch (err) {
       console.log(err);
       this.bagel.onError?.(err);
-      return void 0;
+      return undefined;
     }
   }
   item(id) {
@@ -399,8 +422,7 @@ class DataRequest {
     return this;
   }
   async delete() {
-    if (!this.data_table)
-      throw new Error("Data table not set");
+    if (!this.data_table) throw new Error("Data table not set");
     const { data } = await axios.delete(
       `/data/${this.data_table}/${this.itemID}`
     );
@@ -408,10 +430,8 @@ class DataRequest {
   }
   async put(updatedItem) {
     const { data_table, itemID } = this;
-    if (!data_table)
-      throw new Error("Data table not set");
-    if (!itemID)
-      throw new Error("Item ID not set");
+    if (!data_table) throw new Error("Data table not set");
+    if (!itemID) throw new Error("Item ID not set");
     const { data } = await axios.put(
       `/data/${data_table}/${itemID}`,
       updatedItem
@@ -429,9 +449,9 @@ function responses(key) {
 class BagelAuth {
   constructor(bagel) {
     this.bagel = bagel;
-    __publicField(this, "user");
     this.bagel = bagel;
   }
+  user = undefined;
   async validateUser() {
     try {
       const { data: usr } = await axios.get("/users/me", {
@@ -479,7 +499,7 @@ class BagelAuth {
       this.bagel.onError?.(err);
       console.log(err);
     }
-    this.user = void 0;
+    this.user = undefined;
   }
   async acceptInvite(token, user) {
     await axios.post(`/auth/accept-invite/${token}`, user);
@@ -497,12 +517,10 @@ class BagelAuth {
   }
 }
 class Bagel {
+  host;
+  fileBaseUrl;
+  onError;
   constructor({ host, fileBaseUrl, onError }) {
-    __publicField(this, "host");
-    __publicField(this, "fileBaseUrl");
-    __publicField(this, "onError");
-    __publicField(this, "read_table");
-    __publicField(this, "auth", new BagelAuth(this));
     this.host = host?.replace(/\/$/, "");
     this.fileBaseUrl = fileBaseUrl?.replace(/\/$/, "");
     if (!this.host) {
@@ -511,9 +529,11 @@ class Bagel {
     axios.defaults.baseURL = this.host;
     this.onError = onError;
   }
+  read_table = undefined;
   data(table) {
     return new DataRequest(table, this);
   }
+  auth = new BagelAuth(this);
   _endpointCleaner(endpoint) {
     const url = `${endpoint.replace(/^\//, "").replaceAll(/\/$/g, "")}`;
     return url;
@@ -528,12 +548,10 @@ class Bagel {
   async get(endpoint, query) {
     this._setAuthorization();
     endpoint = this._endpointCleaner(endpoint);
-    if (/undefined|null/.test(endpoint))
-      throw new Error(`Invalid endpoint: ${endpoint}`);
+    if (/undefined|null/.test(endpoint)) throw new Error(`Invalid endpoint: ${endpoint}`);
     if (query) {
       const queryParams = Object.entries(query).filter(([_, value]) => !!value).map(([key, value]) => `${key}=${value}`).join("&");
-      if (queryParams)
-        endpoint = `${endpoint}?${queryParams}`;
+      if (queryParams) endpoint = `${endpoint}?${queryParams}`;
     }
     const url = `/${endpoint}`;
     return axios.get(url).then(({ data }) => data).catch((err) => {
@@ -583,8 +601,7 @@ class Bagel {
     const formData = new FormData();
     formData.append("file", file);
     let url = "/static_files/upload";
-    if (options?.topic)
-      url = `/static_files/upload?topic=${options.topic}`;
+    if (options?.topic) url = `/static_files/upload?topic=${options.topic}`;
     const { data } = await axios.post(url, formData, {
       headers: {
         "Content-Type": "multipart/form-data"

package/dist/index.mjs

@@ -1,30 +1,31 @@
 import axios$1 from 'axios';
 
-const toCamelCase = (str) => str?.replaceAll(/[-._\s]+(.)?/g, (_, c) => c?.toUpperCase() || "").replace(/^./, (str2) => str2.toLowerCase()) || str || "";
-const toPascalCase = (str) => str?.replaceAll(/[-_\s]+(.)?/g, (_, c) => c?.toUpperCase() || "").replace(/^./, (str2) => str2.toUpperCase()) || str || "";
+function toCamelCase(str) {
+  return str?.replaceAll(/[-._\s]+(.)?/g, (_, c) => c?.toUpperCase() || "").replace(/^./, (str2) => str2.toLowerCase()) || str || "";
+}
+function toPascalCase(str) {
+  return str?.replaceAll(/[-_\s]+(.)?/g, (_, c) => c?.toUpperCase() || "").replace(/^./, (str2) => str2.toUpperCase()) || str || "";
+}
 function formatType(typeName) {
-  typeName = typeName.replaceAll("-", "").replaceAll(/(post|put)$/gi, "").replaceAll(/^body_/gi, "");
+  typeName = typeName.replaceAll("-", "").replaceAll(/post|put$/gi, "").replaceAll(/^body_/gi, "");
   return toPascalCase(typeName);
 }
 function resolveReference(ref) {
   const t = ref.split("/").pop();
-  if (!t)
-    return "any";
+  if (!t) return "any";
   return formatType(t);
 }
 function schemaToType(schema) {
-  if (!schema)
-    return "any";
+  if (!schema) return "any";
   if (schema.anyOf) {
     let _t = schema.anyOf.map((s) => schemaToType(s)).filter((p) => p !== "any").join(" | ");
-    if (_t === "" || _t === "null")
-      _t = "any";
+    if (_t === "" || _t === "null") _t = "any";
     return _t;
   }
-  if (schema.allOf)
+  if (schema.allOf) {
     return schema.allOf.map((s) => schemaToType(s)).filter((p) => p !== "any").join(" & ");
-  if (schema.$ref)
-    return resolveReference(schema.$ref);
+  }
+  if (schema.$ref) return resolveReference(schema.$ref);
   switch (schema.type) {
     case "object":
       return "{ [key: string]: any }";
@@ -42,7 +43,7 @@ function schemaToType(schema) {
       return "undefined";
     case "null":
       return "null";
-    case void 0:
+    case undefined:
       return "any";
     default:
       console.log("Unknown type", schema.type);
@@ -54,10 +55,17 @@ function isOptional(schema) {
   const splitType = type.split(/\s+\|\s+/);
   const includesNull = splitType.includes("null");
   const includesUndefined = splitType.includes("undefined");
-  return includesNull || includesUndefined || schema.default !== void 0;
+  return includesNull || includesUndefined || schema.default !== undefined;
 }
-const cleanOptionals = (str) => str.split(" | ").filter((t) => t !== "null" && t !== "undefined").join(" | ");
-function formatVarType(varName, schema, required = false, defaultValue) {
+function cleanOptionals(str) {
+  return str.split(" | ").filter((t) => t !== "null" && t !== "undefined").join(" | ");
+}
+function formatVarType({
+  varName,
+  schema,
+  required = false,
+  defaultValue
+}) {
   let type = schemaToType(schema);
   type = cleanOptionals(type);
   let defaultStr = "";
@@ -68,9 +76,8 @@ function formatVarType(varName, schema, required = false, defaultValue) {
       defaultStr = ` = ${defaultValue}`;
     }
   }
-  let optionalStr = required || isOptional(schema) ? "?" : "";
-  if (defaultStr)
-    optionalStr = "";
+  let optionalStr = !required && isOptional(schema) ? "?" : "";
+  if (defaultStr) optionalStr = "";
   return `${varName}${optionalStr}: ${type}${defaultStr}`;
 }
 function cleanPath(path) {
@@ -78,35 +85,39 @@ function cleanPath(path) {
 }
 
 const allTypes = [];
-const primitiveTypes = ["string", "number", "boolean", "null", "void", "any", "Record<string, any>", "undefined", "{ [key: string]: any }"];
+const primitiveTypes = [
+  "string",
+  "number",
+  "boolean",
+  "null",
+  "void",
+  "any",
+  "Record<string, any>",
+  "undefined",
+  "{ [key: string]: any }"
+];
 function collectTypeForImportStatement(typeName) {
   typeName = typeName.trim().replace("[]", "");
   if (typeName.includes("|")) {
-    typeName.split("|").forEach(
-      (singleType) => {
-        collectTypeForImportStatement(singleType);
-      }
-    );
+    typeName.split("|").forEach((singleType) => {
+      collectTypeForImportStatement(singleType);
+    });
     return;
   }
   const isPrimitive = primitiveTypes.includes(typeName);
   typeName = formatType(typeName);
-  if (!typeName || isPrimitive)
-    return;
-  if (!allTypes.includes(typeName))
-    allTypes.push(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;
+  if (!mediaTypeObject || !mediaTypeObject.schema) return;
   const responseType = schemaToType(mediaTypeObject.schema);
   collectTypeForImportStatement(responseType);
   return responseType;
 }
 function generateResponseType(responses) {
-  if (!responses)
-    return "";
+  if (!responses) return "";
   const types = [];
   for (const [statusCode, response] of Object.entries(responses)) {
     if (statusCode.startsWith("2")) {
@@ -119,8 +130,7 @@ function generateResponseType(responses) {
   return types.join(" | ");
 }
 function generateAxiosFunction(method, formattedPath, allParams, responseTypeStr, parameters, requestBodyPayload) {
-  if (allParams === "undefined")
-    allParams = "";
+  if (allParams === "undefined") allParams = "";
   let axiosFunction = `async (${allParams})${responseTypeStr} => {`;
   if (requestBodyPayload === "formData") {
     const paramStr = parameters?.config?.params ? `params: {${parameters.config.params}}` : "";
@@ -169,21 +179,23 @@ function generateRequestBody(requestBody) {
   const requestBodyType = schemaToType(bodySchema);
   collectTypeForImportStatement(requestBodyType);
   const requestBodyPayload = toCamelCase(bodySchema.title) || toCamelCase(requestBodyType) || "requestBody";
-  const requestBodyParam = formatVarType(requestBodyPayload, bodySchema, bodySchema.default);
+  const requestBodyParam = formatVarType({
+    varName: requestBodyPayload,
+    schema: bodySchema,
+    defaultValue: bodySchema.default
+  });
   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());
+  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, isFileUpload = false) {
-  if (!params?.length)
-    return {};
+  if (!params?.length) return {};
   if (isFileUpload) {
     return {
       config: {
@@ -201,10 +213,19 @@ function generateFunctionParameters(params, isFileUpload = false) {
     const paramName = param.name;
     const varName = toCamelCase(param.name);
     if (param.in === "path" || param.in === "query" || param.in === "header") {
-      functionParams.push(formatVarType(varName, param.schema, param.required, param.schema.default));
+      functionParams.push(
+        formatVarType({
+          varName,
+          schema: param.schema,
+          required: param.required,
+          defaultValue: param.schema.default
+        })
+      );
     }
     if (param.in === "query" || param.in === "header") {
-      paramList.push(paramName === varName ? paramName : `'${paramName}': ${varName}`);
+      paramList.push(
+        paramName === varName ? paramName : `'${paramName}': ${varName}`
+      );
     }
   }
   return {
@@ -213,11 +234,15 @@ function generateFunctionParameters(params, isFileUpload = false) {
   };
 }
 function generateFunctionForOperation(method, path, operation) {
-  if (!operation)
-    return "";
+  if (!operation) return "";
   const isFileUpload = operation.requestBody?.content["multipart/form-data"]?.schema?.$ref?.includes("Body_upload_files");
-  const parameters = generateFunctionParameters(operation.parameters, isFileUpload);
-  const { requestBodyParam, requestBodyPayload } = generateRequestBody(operation.requestBody);
+  const parameters = generateFunctionParameters(
+    operation.parameters,
+    isFileUpload
+  );
+  const { requestBodyParam, requestBodyPayload } = generateRequestBody(
+    operation.requestBody
+  );
   const allParams = isFileUpload ? "file: File, options?: UploadOptions & { dirPath?: string, tags?: string[] }" : combineAllParams(parameters, requestBodyParam);
   const responseType = generateResponseType(operation.responses);
   const responseTypeStr = responseType ? `: Promise<AxiosResponse<${responseType}>>` : "";
@@ -235,13 +260,13 @@ function fileTemplate(tsString, typeForImport, baseURL) {
   const templateCode = `import ax from 'axios';
 		 import type { AxiosResponse } from 'axios';
 		 import type {${typeForImport.join(", ")}} from './types.d';
-		
+
 	interface UploadOptions {
 		onUploadProgress?: (progressEvent: any) => void
 		dirPath?: string
 		tags?: string[]
 	}
-	
+
 	export const axios = ax.create({baseURL:${baseURL}});
 	${tsString}`;
   const doubleQuoteRegex = /"([^"]+)":/g;
@@ -251,13 +276,19 @@ const functionsInventory = {};
 const pathOperations = [];
 function hasConflict(path, method) {
   const cleanPathName = path.split("/").filter((p) => p && !/\{|\}/.test(p)).join("/");
-  const matchingPaths = pathOperations.filter((p) => p.path === cleanPathName && p.method === method);
+  const matchingPaths = pathOperations.filter(
+    (p) => p.path === cleanPathName && p.method === method
+  );
   pathOperations.push({ path: cleanPathName, method });
   return matchingPaths.length > 0;
 }
 function createFunctionPlaceholder(path, method, operation) {
   const funcID = generateRandomString();
-  functionsInventory[funcID] = generateFunctionForOperation(method, path, operation);
+  functionsInventory[funcID] = generateFunctionForOperation(
+    method,
+    path,
+    operation
+  );
   return funcID;
 }
 function handlePathSegment(path, operation, existingObj = {}) {
@@ -269,7 +300,11 @@ function handlePathSegment(path, operation, existingObj = {}) {
       const params = 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 };
 }
@@ -281,8 +316,7 @@ function generateFunctions(paths, baseUrl) {
     const splitPath = path.split("/").filter((p) => p && !/\{|\}/.test(p));
     splitPath.reduce((acc, key, index, array) => {
       const objFuncKey = toCamelCase(key);
-      if (!objFuncKey)
-        return acc;
+      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];
@@ -297,7 +331,7 @@ function generateFunctions(paths, baseUrl) {
     }, body);
   }
   for (const [parent, object] of Object.entries(body)) {
-    tsString += `export const ${parent} = ${JSON.stringify(object, void 0, 2)};
+    tsString += `export const ${parent} = ${JSON.stringify(object, undefined, 2)};
 `;
   }
   Object.entries(functionsInventory).forEach(([key, value]) => {
@@ -314,10 +348,9 @@ function generateTypes(schemas) {
       return `export type ${typeName} = ${schema.enum.map((item) => `'${item}'`).join(" | ")};
 `;
     }
-    if (!schema.properties)
-      return "";
+    if (!schema.properties) return "";
     const properties = Object.entries(schema.properties).map(([key, value]) => {
-      const varType = formatVarType(key, value);
+      const varType = formatVarType({ varName: key, schema: value });
       return `		${varType}`;
     }).join(";\n ");
     return `export type ${typeName} = {
@@ -332,12 +365,10 @@ const index = async (openApiUrl, baseUrl) => {
   try {
     const { data: openApi } = await axios$1.get(openApiUrl, { headers: basicAuthHeader });
     const schemas = openApi.components?.schemas;
-    if (!schemas)
-      throw new Error("No schemas found in OpenAPI document");
+    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");
+    if (!paths) throw new Error("No paths found in OpenAPI document");
     const code = generateFunctions(paths, baseUrl);
     return { types, code };
   } catch (error) {
@@ -345,28 +376,21 @@ const index = async (openApiUrl, baseUrl) => {
   }
 };
 
-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;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
 const axios = axios$1.create({
   withCredentials: true
 });
 class DataRequest {
+  data_table;
+  bagel;
+  itemID;
+  _filter = {};
   constructor(table, bagel) {
-    __publicField(this, "data_table");
-    __publicField(this, "bagel");
-    __publicField(this, "itemID");
-    __publicField(this, "_filter", {});
     this.data_table = table;
     this.bagel = bagel;
     this.itemID = "";
   }
   async post(item) {
-    if (!this.data_table)
-      throw new Error("Data table not set");
+    if (!this.data_table) throw new Error("Data table not set");
     const { data } = await axios.post(`/data/${this.data_table}`, item);
     return data;
   }
@@ -375,8 +399,7 @@ class DataRequest {
     return this;
   }
   async get() {
-    if (!this.data_table)
-      throw new Error("Data table not set");
+    if (!this.data_table) throw new Error("Data table not set");
     const filterStr = Object.keys(this._filter).length > 0 ? `?filter={${Object.entries(this._filter).map(([k, v]) => `${k}:${v}`).join(",")}}` : "";
     const url = `/data/${this.data_table}${this.itemID ? `/${this.itemID}` : ""}${filterStr}`;
     try {
@@ -385,7 +408,7 @@ class DataRequest {
     } catch (err) {
       console.log(err);
       this.bagel.onError?.(err);
-      return void 0;
+      return undefined;
     }
   }
   item(id) {
@@ -393,8 +416,7 @@ class DataRequest {
     return this;
   }
   async delete() {
-    if (!this.data_table)
-      throw new Error("Data table not set");
+    if (!this.data_table) throw new Error("Data table not set");
     const { data } = await axios.delete(
       `/data/${this.data_table}/${this.itemID}`
     );
@@ -402,10 +424,8 @@ class DataRequest {
   }
   async put(updatedItem) {
     const { data_table, itemID } = this;
-    if (!data_table)
-      throw new Error("Data table not set");
-    if (!itemID)
-      throw new Error("Item ID not set");
+    if (!data_table) throw new Error("Data table not set");
+    if (!itemID) throw new Error("Item ID not set");
     const { data } = await axios.put(
       `/data/${data_table}/${itemID}`,
       updatedItem
@@ -423,9 +443,9 @@ function responses(key) {
 class BagelAuth {
   constructor(bagel) {
     this.bagel = bagel;
-    __publicField(this, "user");
     this.bagel = bagel;
   }
+  user = undefined;
   async validateUser() {
     try {
       const { data: usr } = await axios.get("/users/me", {
@@ -473,7 +493,7 @@ class BagelAuth {
       this.bagel.onError?.(err);
       console.log(err);
     }
-    this.user = void 0;
+    this.user = undefined;
   }
   async acceptInvite(token, user) {
     await axios.post(`/auth/accept-invite/${token}`, user);
@@ -491,12 +511,10 @@ class BagelAuth {
   }
 }
 class Bagel {
+  host;
+  fileBaseUrl;
+  onError;
   constructor({ host, fileBaseUrl, onError }) {
-    __publicField(this, "host");
-    __publicField(this, "fileBaseUrl");
-    __publicField(this, "onError");
-    __publicField(this, "read_table");
-    __publicField(this, "auth", new BagelAuth(this));
     this.host = host?.replace(/\/$/, "");
     this.fileBaseUrl = fileBaseUrl?.replace(/\/$/, "");
     if (!this.host) {
@@ -505,9 +523,11 @@ class Bagel {
     axios.defaults.baseURL = this.host;
     this.onError = onError;
   }
+  read_table = undefined;
   data(table) {
     return new DataRequest(table, this);
   }
+  auth = new BagelAuth(this);
   _endpointCleaner(endpoint) {
     const url = `${endpoint.replace(/^\//, "").replaceAll(/\/$/g, "")}`;
     return url;
@@ -522,12 +542,10 @@ class Bagel {
   async get(endpoint, query) {
     this._setAuthorization();
     endpoint = this._endpointCleaner(endpoint);
-    if (/undefined|null/.test(endpoint))
-      throw new Error(`Invalid endpoint: ${endpoint}`);
+    if (/undefined|null/.test(endpoint)) throw new Error(`Invalid endpoint: ${endpoint}`);
     if (query) {
       const queryParams = Object.entries(query).filter(([_, value]) => !!value).map(([key, value]) => `${key}=${value}`).join("&");
-      if (queryParams)
-        endpoint = `${endpoint}?${queryParams}`;
+      if (queryParams) endpoint = `${endpoint}?${queryParams}`;
     }
     const url = `/${endpoint}`;
     return axios.get(url).then(({ data }) => data).catch((err) => {
@@ -577,8 +595,7 @@ class Bagel {
     const formData = new FormData();
     formData.append("file", file);
     let url = "/static_files/upload";
-    if (options?.topic)
-      url = `/static_files/upload?topic=${options.topic}`;
+    if (options?.topic) url = `/static_files/upload?topic=${options.topic}`;
     const { data } = await axios.post(url, formData, {
       headers: {
         "Content-Type": "multipart/form-data"

package/package.json

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

package/src/openAPITools/functionGenerator.ts

@@ -18,14 +18,24 @@ import {
 
 const allTypes: string[] = []
 
-const primitiveTypes = ['string', 'number', 'boolean', 'null', 'void', 'any', 'Record<string, any>', 'undefined', '{ [key: string]: any }']
+const primitiveTypes = [
+	'string',
+	'number',
+	'boolean',
+	'null',
+	'void',
+	'any',
+	'Record<string, any>',
+	'undefined',
+	'{ [key: string]: any }',
+]
 
 function collectTypeForImportStatement(typeName: string) {
 	typeName = typeName.trim().replace('[]', '')
 	if (typeName.includes('|')) {
-		typeName.split('|').forEach(
-			(singleType) => { collectTypeForImportStatement(singleType) },
-		)
+		typeName.split('|').forEach((singleType) => {
+			collectTypeForImportStatement(singleType)
+		})
 		return
 	}
 	const isPrimitive = primitiveTypes.includes(typeName)
@@ -73,7 +83,7 @@ function generateAxiosFunction(
 	allParams: string,
 	responseTypeStr: string,
 	parameters: any,
-	requestBodyPayload: string,
+	requestBodyPayload: string
 ): string {
 	if (allParams === 'undefined') allParams = ''
 
@@ -92,7 +102,9 @@ function generateAxiosFunction(
 			onUploadProgress: options?.onUploadProgress${paramStr ? `,\n            ${paramStr}` : ''}
 		})`
 	} else {
-		const paramStr = parameters?.config?.params ? `, { params: {${parameters.config.params}} }` : ''
+		const paramStr = parameters?.config?.params
+			? `, { params: {${parameters.config.params}} }`
+			: ''
 		const bodyVar = requestBodyPayload ? `${requestBodyPayload}` : '{}'
 		axiosFunction += `return axios.${method}(${formattedPath}${['get', 'delete'].includes(method) ? paramStr : `, ${bodyVar}${paramStr}`})`
 	}
@@ -110,19 +122,25 @@ function getParamsFromPath(path: string) {
 
 function formatPathWithParams(path: string) {
 	const params = getParamsFromPath(path)
-	const formattedPath = params ? `\`${path.replace(pathParamRegex, v => `$${toCamelCase(v)}`)}\`` : `'${path}'`
+	const formattedPath = params
+		? `\`${path.replace(pathParamRegex, v => `$${toCamelCase(v)}`)}\``
+		: `'${path}'`
 	return formattedPath
 }
 
-function generateRequestBody(requestBody?: RequestBodyObject): { [key: string]: string } {
-	if (!requestBody?.content) return { requestBodyParam: '', requestBodyPayload: '' }
+function generateRequestBody(requestBody?: RequestBodyObject): {
+	[key: string]: string
+} {
+	if (!requestBody?.content)
+		return { requestBodyParam: '', requestBodyPayload: '' }
 
 	const { content } = requestBody
 	const multipartFormData = content['multipart/form-data'] || {}
 	if (multipartFormData.schema?.$ref?.includes('Body_upload_files')) {
 		return {
-			requestBodyParam: 'file: File, options?: UploadOptions & { dirPath?: string, tags?: string[] }',
-			requestBodyPayload: 'formData'
+			requestBodyParam:
+				'file: File, options?: UploadOptions & { dirPath?: string, tags?: string[] }',
+			requestBodyPayload: 'formData',
 		}
 	}
 
@@ -135,8 +153,16 @@ function generateRequestBody(requestBody?: RequestBodyObject): { [key: string]:
 	const bodySchema = jsonContent.schema
 	const requestBodyType = schemaToType(bodySchema)
 	collectTypeForImportStatement(requestBodyType)
-	const requestBodyPayload = toCamelCase(bodySchema.title) || toCamelCase(requestBodyType) || 'requestBody'
-	const requestBodyParam = formatVarType(requestBodyPayload, bodySchema, bodySchema.default)
+	const requestBodyPayload
+		= toCamelCase(bodySchema.title)
+			|| toCamelCase(requestBodyType)
+			|| 'requestBody'
+
+	const requestBodyParam = formatVarType({
+		varName: requestBodyPayload,
+		schema: bodySchema,
+		defaultValue: bodySchema.default,
+	})
 	return { requestBodyParam, requestBodyPayload }
 }
 
@@ -146,9 +172,13 @@ function generateRequestBody(requestBody?: RequestBodyObject): { [key: string]:
  * @param requestBodyParam - The parameter representing the request body.
  * @returns A string representing all combined parameters.
  */
-function combineAllParams(parameters: { params?: string }, requestBodyParam: string): string {
+function combineAllParams(
+	parameters: { params?: string },
+	requestBodyParam: string
+): string {
 	let allParamsArray: string[] = []
-	if (parameters && parameters.params) allParamsArray = parameters.params.split(',').map(p => p.trim())
+	if (parameters && parameters.params)
+		allParamsArray = parameters.params.split(',').map(p => p.trim())
 	if (requestBodyParam) allParamsArray.push(requestBodyParam.trim())
 
 	allParamsArray = allParamsArray
@@ -158,7 +188,10 @@ function combineAllParams(parameters: { params?: string }, requestBodyParam: str
 	return allParamsArray.join(', ')
 }
 
-function generateFunctionParameters(params?: ParameterObject[], isFileUpload = false) {
+function generateFunctionParameters(
+	params?: ParameterObject[],
+	isFileUpload = false
+) {
 	if (!params?.length) return {}
 
 	// For file uploads, we want to handle query parameters differently
@@ -166,9 +199,9 @@ function generateFunctionParameters(params?: ParameterObject[], isFileUpload = f
 		// Don't include these as function parameters, they'll be part of options
 		return {
 			config: {
-				params: 'dir_path: options?.dirPath, tags: options?.tags'
+				params: 'dir_path: options?.dirPath, tags: options?.tags',
 			},
-			params: '' // Empty string to ensure file is the first parameter
+			params: '', // Empty string to ensure file is the first parameter
 		}
 	}
 
@@ -182,27 +215,48 @@ function generateFunctionParameters(params?: ParameterObject[], isFileUpload = f
 		const varName = toCamelCase(param.name)
 
 		if (param.in === 'path' || param.in === 'query' || param.in === 'header') {
-			functionParams.push(formatVarType(varName, param.schema, param.required, param.schema.default))
+			functionParams.push(
+				formatVarType({
+					varName,
+					schema: param.schema,
+					required: param.required,
+					defaultValue: param.schema.default,
+				})
+			)
 		}
 
 		if (param.in === 'query' || param.in === 'header') {
-			paramList.push(paramName === varName ? paramName : `'${paramName}': ${varName}`)
+			paramList.push(
+				paramName === varName ? paramName : `'${paramName}': ${varName}`
+			)
 		}
 	}
 
 	return {
 		params: functionParams.join(', '),
-		config: paramList.length ? { params: paramList.join(', ') } : {}
+		config: paramList.length ? { params: paramList.join(', ') } : {},
 	}
 }
 
-function generateFunctionForOperation(method: string, path: string, operation: OperationObject): string {
+function generateFunctionForOperation(
+	method: string,
+	path: string,
+	operation: OperationObject
+): string {
 	if (!operation) return ''
 
 	// Check if this is a file upload operation by looking at the schema reference
-	const isFileUpload = operation.requestBody?.content['multipart/form-data']?.schema?.$ref?.includes('Body_upload_files')
-	const parameters = generateFunctionParameters(operation.parameters, isFileUpload)
-	const { requestBodyParam, requestBodyPayload } = generateRequestBody(operation.requestBody)
+	const isFileUpload
+		= operation.requestBody?.content[
+			'multipart/form-data'
+		]?.schema?.$ref?.includes('Body_upload_files')
+	const parameters = generateFunctionParameters(
+		operation.parameters,
+		isFileUpload
+	)
+	const { requestBodyParam, requestBodyPayload } = generateRequestBody(
+		operation.requestBody
+	)
 
 	// For file uploads, ignore the regular parameter generation
 	const allParams = isFileUpload
@@ -210,7 +264,9 @@ function generateFunctionForOperation(method: string, path: string, operation: O
 		: combineAllParams(parameters, requestBodyParam)
 
 	const responseType = generateResponseType(operation.responses)
-	const responseTypeStr = responseType ? `: Promise<AxiosResponse<${responseType}>>` : ''
+	const responseTypeStr = responseType
+		? `: Promise<AxiosResponse<${responseType}>>`
+		: ''
 
 	return generateAxiosFunction(
 		method,
@@ -224,21 +280,23 @@ function generateFunctionForOperation(method: string, path: string, operation: O
 
 const generateRandomString = () => Math.random().toString(36).slice(7)
 
-function fileTemplate(tsString: string, typeForImport: string[], baseURL: string) {
-	const templateCode = (
-		`import ax from 'axios';
+function fileTemplate(
+	tsString: string,
+	typeForImport: string[],
+	baseURL: string
+) {
+	const templateCode = `import ax from 'axios';
 		 import type { AxiosResponse } from 'axios';
 		 import type {${typeForImport.join(', ')}} from './types.d';
-		
+
 	interface UploadOptions {
 		onUploadProgress?: (progressEvent: any) => void
 		dirPath?: string
 		tags?: string[]
 	}
-	
+
 	export const axios = ax.create({baseURL:${baseURL}});
 	${tsString}`
-	)
 	const doubleQuoteRegex = /"([^"]+)":/g
 	return templateCode.replace(doubleQuoteRegex, '$1:')
 }
@@ -252,23 +310,36 @@ const functionsInventory: Record<string, string> = {}
 const pathOperations: PathOperation[] = []
 
 function hasConflict(path: string, method: string) {
-	const cleanPathName = path.split('/').filter(p => p && !(/\{|\}/).test(p)).join('/')
-	const matchingPaths = pathOperations.filter(p => p.path === cleanPathName && p.method === method)
+	const cleanPathName = path
+		.split('/')
+		.filter(p => p && !/\{|\}/.test(p))
+		.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
-function createFunctionPlaceholder(path: string, method: string, operation: any) {
+function createFunctionPlaceholder(
+	path: string,
+	method: string,
+	operation: any
+) {
 	const funcID = generateRandomString()
-	functionsInventory[funcID] = generateFunctionForOperation(method, path, operation)
+	functionsInventory[funcID] = generateFunctionForOperation(
+		method,
+		path,
+		operation
+	)
 	return funcID
 }
 
 function handlePathSegment(
 	path: string,
 	operation: any,
-	existingObj: { [key: string]: any } = {},
+	existingObj: { [key: string]: any } = {}
 ) {
 	const methods = Object.keys(operation)
 	const obj: { [key: string]: any } = {}
@@ -276,9 +347,13 @@ function handlePathSegment(
 		let functionName = method.toLowerCase()
 		if (hasConflict(path, method)) {
 			const params: string[] | undefined = getParamsFromPath(path)
-			functionName += (params ? `By${toPascalCase(params.pop() || '')}` : 'All')
+			functionName += params ? `By${toPascalCase(params.pop() || '')}` : 'All'
 		}
-		obj[functionName] = createFunctionPlaceholder(path, method, operation[method])
+		obj[functionName] = createFunctionPlaceholder(
+			path,
+			method,
+			operation[method]
+		)
 	}
 	return { ...obj, ...existingObj }
 }
@@ -288,7 +363,7 @@ export function generateFunctions(paths: PathsObject, baseUrl: string) {
 	const body: { [key: string]: any } = {}
 	const allPathsClean = Object.keys(paths).map(cleanPath)
 	for (const [path, operation] of Object.entries(paths)) {
-		const splitPath = path.split('/').filter(p => p && !(/\{|\}/).test(p))
+		const splitPath = path.split('/').filter(p => p && !/\{|\}/.test(p))
 		splitPath.reduce((acc, key: string, index: number, array: string[]) => {
 			const objFuncKey = toCamelCase(key)
 			if (!objFuncKey) return acc
@@ -301,11 +376,10 @@ export function generateFunctions(paths: PathsObject, baseUrl: string) {
 				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] = {}
+			} 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)

package/src/openAPITools/typeGenerator.ts

@@ -11,7 +11,7 @@ export function generateTypes(schemas: SchemasObject): string {
 		if (!schema.properties) return ''
 
 		const properties = Object.entries(schema.properties).map(([key, value]) => {
-			const varType = formatVarType(key, value)
+			const varType = formatVarType({ varName: key, schema: value })
 
 			return `\t\t${varType}`
 		}).join(';\n ')

package/src/openAPITools/utils.ts

@@ -1,11 +1,25 @@
 import type { SchemaObject } from './openApiTypes'
 
-export const toCamelCase = (str?: string) => str?.replaceAll(/[-._\s]+(.)?/g, (_, c) => c?.toUpperCase() || '').replace(/^./, str => str.toLowerCase()) || str || ''
-export const toPascalCase = (str?: string) => str?.replaceAll(/[-_\s]+(.)?/g, (_, c) => c?.toUpperCase() || '').replace(/^./, str => str.toUpperCase()) || str || ''
+export function toCamelCase(str?: string) {
+	return str
+		?.replaceAll(/[-._\s]+(.)?/g, (_, c) => c?.toUpperCase() || '')
+		.replace(/^./, str => str.toLowerCase())
+		|| str
+		|| ''
+}
+export function toPascalCase(str?: string) {
+	return str
+		?.replaceAll(/[-_\s]+(.)?/g, (_, c) => c?.toUpperCase() || '')
+		.replace(/^./, str => str.toUpperCase())
+		|| str
+		|| ''
+}
 
 export function formatType(typeName: string): string {
-	// eslint-disable-next-line regexp/no-unused-capturing-group
-	typeName = typeName.replaceAll('-', '').replaceAll(/(post|put)$/gi, '').replaceAll(/^body_/gi, '')
+	typeName = typeName
+		.replaceAll('-', '')
+		.replaceAll(/post|put$/gi, '')
+		.replaceAll(/^body_/gi, '')
 	return toPascalCase(typeName)!
 }
 
@@ -18,11 +32,19 @@ function resolveReference(ref: string): string {
 export function schemaToType(schema?: SchemaObject): string {
 	if (!schema) return 'any'
 	if (schema.anyOf) {
-		let _t = schema.anyOf.map(s => schemaToType(s)).filter(p => p !== 'any').join(' | ')
+		let _t = schema.anyOf
+			.map(s => schemaToType(s))
+			.filter(p => p !== 'any')
+			.join(' | ')
 		if (_t === '' || _t === 'null') _t = 'any'
 		return _t
 	}
-	if (schema.allOf) return schema.allOf.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':
@@ -59,9 +81,24 @@ export function isOptional(schema: SchemaObject) {
 	return includesNull || includesUndefined || schema.default !== undefined
 }
 
-export const cleanOptionals = (str: string) => str.split(' | ').filter(t => t !== 'null' && t !== 'undefined').join(' | ')
+export function cleanOptionals(str: string) {
+	return str
+		.split(' | ')
+		.filter(t => t !== 'null' && t !== 'undefined')
+		.join(' | ')
+}
 
-export function formatVarType(varName: string, schema: any, required = false, defaultValue?: unknown) {
+export function formatVarType({
+	varName,
+	schema,
+	required = false,
+	defaultValue,
+}: {
+	varName: string
+	schema: SchemaObject
+	required?: boolean
+	defaultValue?: unknown
+}) {
 	let type = schemaToType(schema)
 	type = cleanOptionals(type)
 
@@ -74,12 +111,16 @@ export function formatVarType(varName: string, schema: any, required = false, de
 		}
 	}
 
-	let optionalStr = required || isOptional(schema) ? '?' : ''
+	let optionalStr = (!required && isOptional(schema)) ? '?' : ''
+
 	if (defaultStr) optionalStr = ''
 
 	return `${varName}${optionalStr}: ${type}${defaultStr}`
 }
 
 export function cleanPath(path: string) {
-	return path.split('/').filter(p => p && !(/\{|\}/).test(p)).join('/')
+	return path
+		.split('/')
+		.filter(p => p && !/\{|\}/.test(p))
+		.join('/')
 }