@bagelink/sdk 1.5.17 → 1.5.22

package/bin/index.ts

@@ -14,7 +14,7 @@ export async function loadTypes() {
 		'import.meta.env.VITE_BAGEL_BASE_URL'
 	)
 
-	if (!fs.existsSync(bagelinkDir)) fs.mkdirSync(bagelinkDir)
+	if (!fs.existsSync(bagelinkDir)) {fs.mkdirSync(bagelinkDir)}
 
 	// Generate monolithic files first
 	const typesPath = join(bagelinkDir, 'types.d.ts')

package/bin/splitClientGen.ts

@@ -10,7 +10,7 @@ import { formatAndWriteCode } from './utils'
  * @returns The camelCase version of the string
  */
 function toCamelCase(str: string): string {
-	if (!str) return ''
+	if (!str) {return ''}
 	return str.charAt(0).toLowerCase() + str.slice(1)
 }
 
@@ -67,7 +67,7 @@ export function createDefaultGroupingStrategy(groupingPattern = /^([A-Z][a-z]+)/
 
 		getFileName(group: string, kind: 'types' | 'api'): string {
 			// Use the utility function for consistent camelCase conversion
-			const suffix = kind === 'types' ? 'Types' : 'Api'
+			const suffix = 'types' === kind ? 'Types' : 'Api'
 			return `${toCamelCase(group)}${suffix}.ts`
 		}
 	}
@@ -108,8 +108,8 @@ export async function splitClientCode(options: SplitClientOptions): Promise<void
 	const apisDir = useDirectories ? path.join(bagelinkDir, 'api') : bagelinkDir
 
 	if (useDirectories) {
-		if (!fs.existsSync(typesDir)) fs.mkdirSync(typesDir, { recursive: true })
-		if (!fs.existsSync(apisDir)) fs.mkdirSync(apisDir, { recursive: true })
+		if (!fs.existsSync(typesDir)) {fs.mkdirSync(typesDir, { recursive: true })}
+		if (!fs.existsSync(apisDir)) {fs.mkdirSync(apisDir, { recursive: true })}
 	}
 
 	// Read the generated files
@@ -152,7 +152,7 @@ export async function splitClientCode(options: SplitClientOptions): Promise<void
 	// Generate and write files for each group
 	for (const [group, info] of Object.entries(groups)) {
 		// Write types file
-		if (info.types.size > 0) {
+		if (0 < info.types.size) {
 			const dependencies = getDependencyImports(info.dependencies, groups, 'types')
 			const typesOutput = generateTypesFile(group, info.types, typesContent, dependencies)
 			const typesFileName = useDirectories
@@ -163,7 +163,7 @@ export async function splitClientCode(options: SplitClientOptions): Promise<void
 		}
 
 		// Write API file
-		if (info.apis.size > 0) {
+		if (0 < info.apis.size) {
 			const dependencies = getDependencyImports(info.dependencies, groups, 'apis')
 			const apisOutput = generateApiFile(
 				group,
@@ -186,7 +186,7 @@ export async function splitClientCode(options: SplitClientOptions): Promise<void
 	if (useDirectories) {
 		// Types index
 		const typesIndexContent = Object.keys(groups)
-			.filter(group => groups[group].types.size > 0)
+			.filter(group => 0 < groups[group].types.size)
 			.map(group => `export * from './${toCamelCase(group)}Types';`)
 			.join('\n')
 
@@ -199,7 +199,7 @@ export async function splitClientCode(options: SplitClientOptions): Promise<void
 		const apiIndexContent
 			= `export { axios } from './axios';\n${
 				Object.keys(groups)
-					.filter(group => groups[group].apis.size > 0)
+					.filter(group => 0 < groups[group].apis.size)
 					.map(group => `export * from './${toCamelCase(group)}Api';`)
 					.join('\n')}`
 
@@ -218,10 +218,10 @@ export async function splitClientCode(options: SplitClientOptions): Promise<void
 		const indexContent = Object.keys(groups)
 			.map((group) => {
 				const exports = []
-				if (groups[group].types.size > 0) {
+				if (0 < groups[group].types.size) {
 					exports.push(`export * from './${toCamelCase(group)}Types';`)
 				}
-				if (groups[group].apis.size > 0) {
+				if (0 < groups[group].apis.size) {
 					exports.push(`export * from './${toCamelCase(group)}Api';`)
 				}
 				return exports.join('\n')
@@ -256,20 +256,20 @@ function extractCommonCode(apiContent: string): { commonCode: string, axiosInsta
 		}
 
 		// Get imports
-		if (node.type === 'ImportDeclaration') {
+		if ('ImportDeclaration' === node.type) {
 			imports.push(apiContent.substring(node.range[0], node.range[1]))
 		}
 
 		// Get axios setup
-		if (node.type === 'ExportNamedDeclaration'
-			&& node.declaration?.type === 'VariableDeclaration'
-			&& node.declaration.declarations.some(d => d.id.type === 'Identifier' && d.id.name === 'axios')) {
+		if ('ExportNamedDeclaration' === node.type
+			&& 'VariableDeclaration' === node.declaration?.type
+			&& node.declaration.declarations.some(d => 'Identifier' === d.id.type && 'axios' === d.id.name)) {
 			axiosDefinition.push(apiContent.substring(node.range[0], node.range[1]))
 		}
 
 		// Get utility interfaces like UploadOptions
-		if (node.type === 'ExportNamedDeclaration'
-			&& node.declaration?.type === 'TSInterfaceDeclaration') {
+		if ('ExportNamedDeclaration' === node.type
+			&& 'TSInterfaceDeclaration' === node.declaration?.type) {
 			utilityTypes.push(apiContent.substring(node.range[0], node.range[1]))
 		}
 	}
@@ -296,11 +296,11 @@ function organizeTypes(typesContent: string, groupingStrategy: GroupingStrategy)
 
 	for (const node of ast.body) {
 		// Skip nodes without range info
-		if (!node.range) continue
+		if (!node.range) {continue}
 
-		if (node.type === 'ExportNamedDeclaration'
-			&& (node.declaration?.type === 'TSTypeAliasDeclaration'
-				|| node.declaration?.type === 'TSInterfaceDeclaration')) {
+		if ('ExportNamedDeclaration' === node.type
+			&& ('TSTypeAliasDeclaration' === node.declaration?.type
+				|| 'TSInterfaceDeclaration' === node.declaration?.type)) {
 			const typeName = node.declaration.id.name
 			const group = groupingStrategy.getGroupName(typeName)
 
@@ -334,12 +334,12 @@ function organizeApiFunctions(apiContent: string, groupingStrategy: GroupingStra
 
 	// First pass: identify top-level exports
 	for (const node of ast.body) {
-		if (!node.range) continue
+		if (!node.range) {continue}
 
 		// Handle direct function exports
-		if (node.type === 'ExportNamedDeclaration' && node.declaration?.type === 'VariableDeclaration') {
+		if ('ExportNamedDeclaration' === node.type && 'VariableDeclaration' === node.declaration?.type) {
 			for (const declarator of node.declaration.declarations) {
-				if (declarator.id.type === 'Identifier') {
+				if ('Identifier' === declarator.id.type) {
 					const functionName = declarator.id.name
 
 					// Skip utility exports
@@ -348,7 +348,7 @@ function organizeApiFunctions(apiContent: string, groupingStrategy: GroupingStra
 					}
 
 					// Check if this is a nested API object (like `auth: {...}` or `dataExports: {...}`)
-					if (declarator.init?.type === 'ObjectExpression') {
+					if ('ObjectExpression' === declarator.init?.type) {
 						// For object groups, use the object name as the group name directly
 						// rather than applying the grouping strategy
 						const groupName = functionName
@@ -523,11 +523,11 @@ function findTypeDependencies(node: ProgramStatement, _typesContent: string): st
 
 	// Type guard functions for type safety
 	function isTypeReference(node: unknown): node is TSESTree.TSTypeReference {
-		return node !== null && typeof node === 'object' && 'type' in node && node.type === AST_NODE_TYPES.TSTypeReference
+		return null !== node && 'object' === typeof node && 'type' in node && node.type === AST_NODE_TYPES.TSTypeReference
 	}
 
 	function isIdentifier(node: unknown): node is TSESTree.Identifier {
-		return node !== null && typeof node === 'object' && 'type' in node && node.type === AST_NODE_TYPES.Identifier
+		return null !== node && 'object' === typeof node && 'type' in node && node.type === AST_NODE_TYPES.Identifier
 	}
 
 	// Simple approach - extract all identifiers from type references
@@ -540,7 +540,7 @@ function findTypeDependencies(node: ProgramStatement, _typesContent: string): st
 		}
 
 		// Recursively visit child nodes
-		if (node && typeof node === 'object') {
+		if (node && 'object' === typeof node) {
 			// Handle arrays
 			if (Array.isArray(node)) {
 				node.forEach((item) => { visit(item) })
@@ -552,7 +552,7 @@ function findTypeDependencies(node: ProgramStatement, _typesContent: string): st
 
 			// Visit each property
 			Object.entries(node).forEach(([key, value]) => {
-				if (!skipProps.includes(key) && value && typeof value === 'object') {
+				if (!skipProps.includes(key) && value && 'object' === typeof value) {
 					visit(value)
 				}
 			})
@@ -610,11 +610,11 @@ function generateTypesFile(
 	const declarations: string[] = []
 	for (const node of ast.body) {
 		// Skip nodes without range info
-		if (!node.range) continue
+		if (!node.range) {continue}
 
-		if (node.type === 'ExportNamedDeclaration'
-			&& (node.declaration?.type === 'TSTypeAliasDeclaration'
-				|| node.declaration?.type === 'TSInterfaceDeclaration')) {
+		if ('ExportNamedDeclaration' === node.type
+			&& ('TSTypeAliasDeclaration' === node.declaration?.type
+				|| 'TSInterfaceDeclaration' === node.declaration?.type)) {
 			const typeName = node.declaration.id.name
 			if (typeNames.has(typeName)) {
 				declarations.push(typesContent.substring(node.range[0], node.range[1]))
@@ -658,16 +658,16 @@ function generateApiFile(
 	if (useDirectories) {
 		Object.entries(dependencies).forEach(([depGroup, types]) => {
 			// Filter out AxiosResponse as we're importing it directly
-			const filteredTypes = types.filter(t => t !== 'AxiosResponse')
-			if (filteredTypes.length > 0) {
+			const filteredTypes = types.filter(t => 'AxiosResponse' !== t)
+			if (0 < filteredTypes.length) {
 				imports.push(`import type { ${filteredTypes.sort().join(', ')} } from '../types/${toCamelCase(depGroup)}Types';`)
 			}
 		})
 	} else {
 		Object.entries(dependencies).forEach(([depGroup, types]) => {
 			// Filter out AxiosResponse as we're importing it directly
-			const filteredTypes = types.filter(t => t !== 'AxiosResponse')
-			if (filteredTypes.length > 0) {
+			const filteredTypes = types.filter(t => 'AxiosResponse' !== t)
+			if (0 < filteredTypes.length) {
 				imports.push(`import type { ${filteredTypes.sort().join(', ')} } from './${toCamelCase(depGroup)}Types';`)
 			}
 		})
@@ -677,12 +677,12 @@ function generateApiFile(
 	const declarations: string[] = []
 
 	for (const node of ast.body) {
-		if (!node.range) continue
+		if (!node.range) {continue}
 
 		// Handle export declarations
-		if (node.type === 'ExportNamedDeclaration' && node.declaration?.type === 'VariableDeclaration') {
+		if ('ExportNamedDeclaration' === node.type && 'VariableDeclaration' === node.declaration?.type) {
 			for (const declarator of node.declaration.declarations) {
-				if (declarator.id.type === 'Identifier') {
+				if ('Identifier' === declarator.id.type) {
 					const functionName = declarator.id.name
 
 					// Check if this function should be included
@@ -698,7 +698,7 @@ function generateApiFile(
 								&& !comments.some(c => comment.range[1] < c.range[1] && c.range[1] <= node.range[0])
 						)
 
-						if (nodeLeadingComments.length > 0) {
+						if (0 < nodeLeadingComments.length) {
 							startPos = nodeLeadingComments[0].range[0]
 						}
 

package/dist/index.cjs

@@ -10,11 +10,13 @@ function getPath(pathsObject, path) {
   return pathsObject ? pathsObject[path] : void 0;
 }
 function isReferenceObject(obj) {
-  if (!obj) return false;
-  return Object.prototype.hasOwnProperty.call(obj, "$ref");
+  if (!obj) {
+    return false;
+  }
+  return Object.hasOwn(obj, "$ref");
 }
 function isSchemaObject(schema) {
-  return !Object.prototype.hasOwnProperty.call(schema, "$ref");
+  return !Object.hasOwn(schema, "$ref");
 }
 function dereference(property) {
   return property;
@@ -32,7 +34,9 @@ function formatType(typeName) {
 }
 function resolveReference(ref) {
   const t = ref.split("/").pop();
-  if (!t) return "any";
+  if (!t) {
+    return "any";
+  }
   return formatType(t);
 }
 function handleArrayItems(schema) {
@@ -51,21 +55,27 @@ function handleArrayItems(schema) {
   return res;
 }
 function schemaToType(schema) {
-  if (!schema) return "any";
+  if (!schema) {
+    return "any";
+  }
   if (isReferenceObject(schema)) {
-    if (schema.$ref) return resolveReference(schema.$ref);
+    if (schema.$ref) {
+      return resolveReference(schema.$ref);
+    }
   }
   if (!isSchemaObject(schema)) {
     console.warn("Schema is not a SchemaObject:", 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";
+    let _t = schema.anyOf.map((s) => schemaToType(s)).filter((p) => "any" !== p).join(" | ");
+    if ("" === _t || "null" === _t) {
+      _t = "any";
+    }
     return _t;
   }
   if (schema.allOf) {
-    return schema.allOf.map((s) => schemaToType(s)).filter((p) => p !== "any").join(" & ");
+    return schema.allOf.map((s) => schemaToType(s)).filter((p) => "any" !== p).join(" & ");
   }
   switch (schema.type) {
     case "object":
@@ -102,7 +112,7 @@ function isOptional(schema) {
   return includesNull || includesUndefined || schema?.default !== void 0;
 }
 function cleanOptionals(str) {
-  return str.split(" | ").filter((t) => t !== "null" && t !== "undefined").join(" | ");
+  return str.split(" | ").filter((t) => "null" !== t && "undefined" !== t).join(" | ");
 }
 function formatVarType({
   varName,
@@ -114,16 +124,18 @@ function formatVarType({
   type = cleanOptionals(type);
   let defaultStr = "";
   if (defaultValue) {
-    if (typeof defaultValue === "string") {
+    if ("string" === typeof defaultValue) {
       defaultStr = ` = '${defaultValue}'`;
-    } else if (typeof defaultValue === "object") {
+    } else if ("object" === typeof defaultValue) {
       defaultStr = ` = ${JSON.stringify(defaultValue)}`;
     } else {
       defaultStr = ` = ${defaultValue}`;
     }
   }
   let optionalStr = !required && isOptional(schema) ? "?" : "";
-  if (defaultStr) optionalStr = "";
+  if (defaultStr) {
+    optionalStr = "";
+  }
   return `${varName}${optionalStr}: ${type}${defaultStr}`;
 }
 const RESERVED_KEYWORDS = /* @__PURE__ */ new Set([
@@ -236,7 +248,9 @@ const RESERVED_KEYWORDS = /* @__PURE__ */ new Set([
   "Reflect"
 ]);
 function sanitizeVarName(varName) {
-  if (!varName) return varName;
+  if (!varName) {
+    return varName;
+  }
   if (RESERVED_KEYWORDS.has(varName.toLowerCase())) {
     return `${varName}_`;
   }
@@ -273,8 +287,12 @@ function collectTypeForImportStatement(typeName) {
   }
   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 schemaToTypeWithCollection(schema) {
   const type = schemaToType(schema);
@@ -286,16 +304,20 @@ function getResponseType(response) {
     return void 0;
   }
   const mediaTypeObject = response.content?.["application/json"];
-  if (!mediaTypeObject?.schema) return void 0;
+  if (!mediaTypeObject?.schema) {
+    return void 0;
+  }
   return schemaToTypeWithCollection(mediaTypeObject.schema);
 }
 function generateResponseType(responses) {
-  if (!responses) return "";
+  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") {
+      if (responseType && "any" !== responseType) {
         types.push(responseType);
       }
     }
@@ -308,12 +330,14 @@ function getParamsFromPath(path) {
 }
 function formatPathWithParams(path) {
   const params = getParamsFromPath(path);
-  if (!params) return `'${path}'`;
+  if (!params) {
+    return `'${path}'`;
+  }
   return `\`${path.replace(/\{([^}]+)\}/g, (_, paramName) => `\${${toCamelCase(paramName)}}`)}\``;
 }
 function generateRequestBody(requestBody) {
   const content = dereference(requestBody)?.content;
-  if (!content || Object.keys(content).length === 0) {
+  if (!content || 0 === Object.keys(content).length) {
     return { requestBodyParam: "", requestBodyPayload: "" };
   }
   if (content["multipart/form-data"]) {
@@ -345,7 +369,9 @@ function generateRequestBody(requestBody) {
   return { requestBodyParam, requestBodyPayload };
 }
 function generateFunctionParameters(params, isFileUpload = false) {
-  if (!params?.length) return {};
+  if (!params?.length) {
+    return {};
+  }
   if (isFileUpload) {
     return {
       config: {
@@ -364,7 +390,7 @@ function generateFunctionParameters(params, isFileUpload = false) {
     collectTypeForImportStatement(paramType);
     const paramName = param.name;
     const varName = toCamelCaseSafe(param.name);
-    if (param.in === "path" || param.in === "query" || param.in === "header") {
+    if ("path" === param.in || "query" === param.in || "header" === param.in) {
       functionParams.push(
         formatVarType({
           varName,
@@ -374,7 +400,7 @@ function generateFunctionParameters(params, isFileUpload = false) {
         })
       );
     }
-    if (param.in === "query" || param.in === "header") {
+    if ("query" === param.in || "header" === param.in) {
       queryParams.push(
         paramName === varName ? paramName : `'${paramName}': ${varName}`
       );
@@ -392,7 +418,7 @@ function parseParameter(paramStr) {
   const name = nameMatch ? nameMatch[1] : "";
   const typeMatch = trimmed.match(/:\s*([^=]+)/);
   const type = typeMatch ? typeMatch[1].trim() : "any";
-  const defaultMatch = trimmed.match(/=(.+)$/);
+  const defaultMatch = trimmed.match(/[=](.+)$/);
   const defaultValue = defaultMatch ? defaultMatch[1].trim() : void 0;
   return { name, type, defaultValue, isOptional };
 }
@@ -404,7 +430,7 @@ function combineAllParams(parameters, requestBodyParam) {
   if (requestBodyParam) {
     allParamsArray.push(requestBodyParam.trim());
   }
-  if (allParamsArray.length === 0) {
+  if (0 === allParamsArray.length) {
     return "";
   }
   const parsedParams = allParamsArray.filter(Boolean).map(parseParameter);
@@ -415,10 +441,12 @@ function combineAllParams(parameters, requestBodyParam) {
   return `{ ${destructuredNames} }: { ${typeDefinition} } = {}`;
 }
 function generateAxiosFunction(method, formattedPath, allParams, responseTypeStr, parameters, requestBodyPayload) {
-  if (allParams === "undefined") allParams = "";
+  if ("undefined" === allParams) {
+    allParams = "";
+  }
   let axiosFunction = `async (${allParams})${responseTypeStr} => {`;
   const paramStr = parameters.config?.params ? `params: {${parameters.config.params}}` : "";
-  if (requestBodyPayload === "formData") {
+  if ("formData" === requestBodyPayload) {
     if (allParams.includes("file: File")) {
       axiosFunction += `
         const formData = new FormData()
@@ -448,8 +476,10 @@ function buildJSDocComment(operation, method, path) {
 `;
   }
   if (operation.description) {
-    if (operation.summary) functionComment += ` *
+    if (operation.summary) {
+      functionComment += ` *
 `;
+    }
     const descriptionLines = operation.description.split("\n");
     descriptionLines.forEach((line) => {
       functionComment += ` * ${line}
@@ -463,7 +493,9 @@ function buildJSDocComment(operation, method, path) {
   return functionComment;
 }
 function generateFunctionForOperation(method, path, operation) {
-  if (!operation) return "";
+  if (!operation) {
+    return "";
+  }
   const multiPartSchema = dereference(operation.requestBody)?.content?.["multipart/form-data"]?.schema;
   const isFileUpload = isReferenceObject(multiPartSchema) && multiPartSchema?.$ref?.includes("Body_upload_files");
   const parameters = generateFunctionParameters(
@@ -492,7 +524,7 @@ function hasConflict(path, method) {
     (p) => p.path === cleanPathName && p.method === method
   );
   pathOperations.push({ path: cleanPathName, method });
-  return matchingPaths.length > 0;
+  return 0 < matchingPaths.length;
 }
 function generateRandomString() {
   return Math.random().toString(36).slice(7);
@@ -534,15 +566,17 @@ function generateFunctions(paths, baseUrl) {
     const splitPath = path.split("/").filter((p) => p && !/\{|\}/.test(p));
     splitPath.reduce((acc, key, index, array) => {
       const objFuncKey = toCamelCaseSafe(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) {
+      if (index === array.length - 1 && 1 === methods.length && 1 === allPathsClean.filter((p) => p === cleanPath(path)).length) {
         const method = methods[0];
         const opp = operation[method];
         acc[objFuncKey] = createFunctionPlaceholder(path, method, opp);
       } else if (index === array.length - 1) {
         acc[objFuncKey] = handlePathSegment(path, operation, acc[objFuncKey]);
-      } else if (!acc[objFuncKey] || typeof acc[objFuncKey] !== "object") {
+      } else if (!acc[objFuncKey] || "object" !== typeof acc[objFuncKey]) {
         acc[objFuncKey] = {};
       }
       return acc[objFuncKey];
@@ -591,27 +625,31 @@ ${tsString}`;
 }
 
 function generateTypes(schemas) {
-  if (!schemas) return "";
+  if (!schemas) {
+    return "";
+  }
   const schemaEntries = Object.entries(schemas);
   return schemaEntries.map(([_typeName, schema]) => {
     const typeName = formatType(_typeName);
-    if (!isSchemaObject(schema)) return "";
+    if (!isSchemaObject(schema)) {
+      return "";
+    }
     if (schema?.enum) {
       return `export type ${typeName} = ${schema.enum.map((item) => `'${item}'`).join(" | ")};
 `;
     }
-    if (schema?.type === "array" && schema.items) {
+    if ("array" === schema?.type && schema.items) {
       return `export type ${typeName} = (${schemaToType(schema.items)})[];
 `;
     }
     if (!schema.properties) {
-      if (schema.additionalProperties === true) {
+      if (true === schema.additionalProperties) {
         return `export type ${typeName} = { [key: string]: any };
 `;
       }
       return "";
     }
-    if (Object.keys(schema.properties).length === 0 && schema.additionalProperties === true) {
+    if (0 === Object.keys(schema.properties).length && true === schema.additionalProperties) {
       return `export type ${typeName} = { [key: string]: any };
 `;
     }
@@ -619,7 +657,7 @@ function generateTypes(schemas) {
       const varType = formatVarType({ varName: key, schema: value });
       return `		${varType}`;
     }).join(";\n ");
-    const indexSignature = schema.additionalProperties === true ? "\n		[key: string]: any;" : "";
+    const indexSignature = true === schema.additionalProperties ? "\n		[key: string]: any;" : "";
     return `export type ${typeName} = {
  ${properties};${indexSignature}
  };
@@ -632,10 +670,14 @@ 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) {
@@ -669,7 +711,7 @@ function formatAPIErrorMessage(err) {
     case 500:
       return "An internal server error occurred. Please try again later.";
   }
-  if (data.detail && typeof data.detail === "string") {
+  if (data.detail && "string" === typeof data.detail) {
     return data.detail;
   }
   if (data.message) {
@@ -692,7 +734,9 @@ class DataRequest {
     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;
   }
@@ -701,8 +745,10 @@ class DataRequest {
     return this;
   }
   async get() {
-    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(",")}}` : "";
+    if (!this.data_table) {
+      throw new Error("Data table not set");
+    }
+    const filterStr = 0 < Object.keys(this._filter).length ? `?filter={${Object.entries(this._filter).map(([k, v]) => `${k}:${v}`).join(",")}}` : "";
     const url = `/data/${this.data_table}${this.itemID ? `/${this.itemID}` : ""}${filterStr}`;
     try {
       const { data } = await axios.get(url);
@@ -718,7 +764,9 @@ 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}`
     );
@@ -726,8 +774,12 @@ 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
@@ -845,10 +897,14 @@ 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) => {
@@ -898,7 +954,9 @@ 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"