@bagelink/sdk 0.0.1123 → 0.0.1125

package/dist/index.cjs

@@ -6,10 +6,14 @@ 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) {
@@ -24,8 +28,9 @@ function schemaToType(schema) {
     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);
   switch (schema.type) {
     case "object":
@@ -58,14 +63,15 @@ function isOptional(schema) {
   const includesUndefined = splitType.includes("undefined");
   return includesNull || includesUndefined || schema.default !== undefined;
 }
-const cleanOptionals = (str) => str.split(" | ").filter((t) => t !== "null" && t !== "undefined").join(" | ");
+function cleanOptionals(str) {
+  return str.split(" | ").filter((t) => t !== "null" && t !== "undefined").join(" | ");
+}
 function formatVarType({
   varName,
   schema,
   required = false,
   defaultValue
 }) {
-  if (varName === "personId") console.log({ varName, schema, required, defaultValue });
   let type = schemaToType(schema);
   type = cleanOptionals(type);
   let defaultStr = "";

package/dist/index.mjs

@@ -1,9 +1,13 @@
 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) {
@@ -18,8 +22,9 @@ function schemaToType(schema) {
     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);
   switch (schema.type) {
     case "object":
@@ -52,14 +57,15 @@ function isOptional(schema) {
   const includesUndefined = splitType.includes("undefined");
   return includesNull || includesUndefined || schema.default !== undefined;
 }
-const cleanOptionals = (str) => str.split(" | ").filter((t) => t !== "null" && t !== "undefined").join(" | ");
+function cleanOptionals(str) {
+  return str.split(" | ").filter((t) => t !== "null" && t !== "undefined").join(" | ");
+}
 function formatVarType({
   varName,
   schema,
   required = false,
   defaultValue
 }) {
-  if (varName === "personId") console.log({ varName, schema, required, defaultValue });
   let type = schemaToType(schema);
   type = cleanOptionals(type);
   let defaultStr = "";

package/package.json

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

package/src/openAPITools/functionGenerator.ts

@@ -33,7 +33,7 @@ const primitiveTypes = [
 function collectTypeForImportStatement(typeName: string) {
 	typeName = typeName.trim().replace('[]', '')
 	if (typeName.includes('|')) {
-		typeName.split('|').forEach(singleType => {
+		typeName.split('|').forEach((singleType) => {
 			collectTypeForImportStatement(singleType)
 		})
 		return
@@ -153,10 +153,10 @@ function generateRequestBody(requestBody?: RequestBodyObject): {
 	const bodySchema = jsonContent.schema
 	const requestBodyType = schemaToType(bodySchema)
 	collectTypeForImportStatement(requestBodyType)
-	const requestBodyPayload =
-		toCamelCase(bodySchema.title) ||
-		toCamelCase(requestBodyType) ||
-		'requestBody'
+	const requestBodyPayload
+		= toCamelCase(bodySchema.title)
+			|| toCamelCase(requestBodyType)
+			|| 'requestBody'
 
 	const requestBodyParam = formatVarType({
 		varName: requestBodyPayload,
@@ -246,8 +246,8 @@ function generateFunctionForOperation(
 	if (!operation) return ''
 
 	// Check if this is a file upload operation by looking at the schema reference
-	const isFileUpload =
-		operation.requestBody?.content[
+	const isFileUpload
+		= operation.requestBody?.content[
 			'multipart/form-data'
 		]?.schema?.$ref?.includes('Body_upload_files')
 	const parameters = generateFunctionParameters(
@@ -369,9 +369,9 @@ export function generateFunctions(paths: PathsObject, baseUrl: string) {
 			if (!objFuncKey) return acc
 			const methods = Object.keys(operation)
 			if (
-				index === array.length - 1 &&
-				methods.length === 1 &&
-				allPathsClean.filter(p => p === cleanPath(path)).length === 1
+				index === array.length - 1
+				&& methods.length === 1
+				&& allPathsClean.filter(p => p === cleanPath(path)).length === 1
 			) {
 				const method: string = methods[0]
 				const opp: any = { ...operation }[method]

package/src/openAPITools/utils.ts

@@ -1,23 +1,24 @@
 import type { SchemaObject } from './openApiTypes'
 
-export const toCamelCase = (str?: string) =>
-	str
+export function toCamelCase(str?: string) {
+	return str
 		?.replaceAll(/[-._\s]+(.)?/g, (_, c) => c?.toUpperCase() || '')
-		.replace(/^./, str => str.toLowerCase()) ||
-	str ||
-	''
-export const toPascalCase = (str?: string) =>
-	str
+		.replace(/^./, str => str.toLowerCase())
+		|| str
+		|| ''
+}
+export function toPascalCase(str?: string) {
+	return str
 		?.replaceAll(/[-_\s]+(.)?/g, (_, c) => c?.toUpperCase() || '')
-		.replace(/^./, str => str.toUpperCase()) ||
-	str ||
-	''
+		.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(/post|put$/gi, '')
 		.replaceAll(/^body_/gi, '')
 	return toPascalCase(typeName)!
 }
@@ -38,11 +39,12 @@ export function schemaToType(schema?: SchemaObject): string {
 		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)
 	switch (schema.type) {
 		case 'object':
@@ -79,11 +81,12 @@ export function isOptional(schema: SchemaObject) {
 	return includesNull || includesUndefined || schema.default !== undefined
 }
 
-export const cleanOptionals = (str: string) =>
-	str
+export function cleanOptionals(str: string) {
+	return str
 		.split(' | ')
 		.filter(t => t !== 'null' && t !== 'undefined')
 		.join(' | ')
+}
 
 export function formatVarType({
 	varName,
@@ -96,8 +99,6 @@ export function formatVarType({
 	required?: boolean
 	defaultValue?: unknown
 }) {
-	if (varName === 'personId') console.log({ varName, schema, required, defaultValue });
-
 	let type = schemaToType(schema)
 	type = cleanOptionals(type)