@bagelink/sdk 1.15.558 → 1.15.562

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bagelink/sdk",
   "type": "module",
-  "version": "1.15.558",
+  "version": "1.15.562",
   "description": "Bagel core sdk packages",
   "author": {
     "name": "Bagel Studio",

package/src/index.ts

@@ -1,7 +1,14 @@
-import type { AxiosResponse, AxiosRequestConfig, InternalAxiosRequestConfig, AxiosError } from 'axios'
+import type { AxiosResponse, AxiosRequestConfig, InternalAxiosRequestConfig, AxiosError, AxiosInstance } from 'axios'
 import type { Ref } from 'vue'
 import ax from 'axios'
 import { ref } from 'vue'
+import type { StreamEventMap } from './openAPITools/StreamController'
+import {
+	createSSEStream,
+	createSSEStreamPost,
+	type SSEStreamOptions,
+	type StreamController
+} from './openAPITools/streamClient'
 
 export * from './openAPITools'
 export { default as openAPI } from './openAPITools'
@@ -324,6 +331,155 @@ export interface ApiConfig {
 	axiosConfig?: AxiosRequestConfig
 }
 
+/**
+ * Instance-scoped HTTP and SSE transport used by generated clients.
+ */
+export interface ApiTransport {
+	axios: AxiosInstance
+	config: Ref<ApiConfig | null>
+	lastResponse: Ref<AxiosResponse | null>
+	getStreamBaseURL: () => string
+	createSSEStream: <TEventMap extends StreamEventMap = StreamEventMap>(
+		path: string,
+		options?: SSEStreamOptions
+	) => StreamController<TEventMap>
+	createSSEStreamPost: <TEventMap extends StreamEventMap = StreamEventMap, TBody = any>(
+		path: string,
+		body: TBody,
+		options?: SSEStreamOptions
+	) => StreamController<TEventMap>
+}
+
+function joinURL(baseURL: string, path: string): string {
+	if (/^https?:\/\//i.test(path)) return path
+	if (!baseURL) return path
+	return `${baseURL.replace(/\/$/, '')}/${path.replace(/^\//, '')}`
+}
+
+async function getTransportHeaders(config: ApiConfig, options: SSEStreamOptions): Promise<Record<string, string>> {
+	const optionHeaders = typeof options.headers === 'function'
+		? await options.headers()
+		: (options.headers ?? {})
+	const configuredHeaders = config.axiosConfig?.headers
+	const headers = typeof configuredHeaders?.toJSON === 'function'
+		? configuredHeaders.toJSON()
+		: (configuredHeaders ?? {})
+	const token = await config.auth?.getToken?.()
+
+	return {
+		...(headers as Record<string, string>),
+		...(token ? { Authorization: `${config.auth?.tokenPrefix ?? 'Bearer'} ${token}` } : {}),
+		...optionHeaders,
+	}
+}
+
+/**
+ * Create an isolated transport. Multiple generated clients can safely use
+ * different base URLs, credentials, auth providers, and interceptors.
+ */
+export function createApiTransport(config: ApiConfig = {}): ApiTransport {
+	const configRef = ref<ApiConfig | null>(null)
+	const lastResponse = ref<AxiosResponse | null>(null)
+	const axios = ax.create({
+		baseURL: config.baseURL,
+		withCredentials: config.withCredentials ?? config.axiosConfig?.withCredentials ?? true,
+		paramsSerializer: { indexes: null },
+		...config.axiosConfig,
+	})
+	const streamOptions = async (options: SSEStreamOptions = {}): Promise<SSEStreamOptions> => {
+		const currentConfig = configRef.value ?? {}
+		return {
+			...options,
+			withCredentials: options.withCredentials ?? currentConfig.withCredentials,
+			headers: await getTransportHeaders(currentConfig, options),
+		}
+	}
+	const streamURL = (path: string) => joinURL(
+		configRef.value?.streamBaseURL ?? axios.defaults.baseURL ?? '',
+		path
+	)
+
+	const transport: ApiTransport = {
+		axios,
+		config: configRef,
+		lastResponse,
+		getStreamBaseURL: () => configRef.value?.streamBaseURL ?? axios.defaults.baseURL ?? '',
+		createSSEStream: <TEventMap extends StreamEventMap = StreamEventMap>(
+			path: string,
+			options: SSEStreamOptions = {}
+		) => createSSEStream<TEventMap>(streamURL(path), {
+			...options,
+			headers: async () => (await streamOptions(options)).headers as Record<string, string>,
+			withCredentials: options.withCredentials ?? configRef.value?.withCredentials,
+		}),
+		createSSEStreamPost: <TEventMap extends StreamEventMap = StreamEventMap, TBody = any>(
+			path: string,
+			body: TBody,
+			options: SSEStreamOptions = {}
+		) => createSSEStreamPost<TEventMap, TBody>(streamURL(path), body, {
+			...options,
+			headers: async () => (await streamOptions(options)).headers as Record<string, string>,
+			withCredentials: options.withCredentials ?? configRef.value?.withCredentials,
+		}),
+	}
+	return configureApiTransport(transport, config)
+}
+
+/**
+ * Reconfigure an existing transport without changing its Axios identity.
+ * This supports legacy generated `axios` exports while keeping bindings isolated.
+ */
+export function configureApiTransport(transport: ApiTransport, config: ApiConfig = {}): ApiTransport {
+	const previousConfig = transport.config.value ?? {}
+	const resolvedConfig: ApiConfig = {
+		...previousConfig,
+		...config,
+		axiosConfig: {
+			...previousConfig.axiosConfig,
+			...config.axiosConfig,
+		},
+		withCredentials: config.withCredentials
+			?? config.axiosConfig?.withCredentials
+			?? previousConfig.withCredentials
+			?? true,
+	}
+	transport.config.value = resolvedConfig
+	transport.axios.defaults.baseURL = resolvedConfig.baseURL
+	transport.axios.defaults.withCredentials = resolvedConfig.withCredentials
+	if (resolvedConfig.axiosConfig) {
+		Object.assign(transport.axios.defaults, resolvedConfig.axiosConfig)
+	}
+	transport.axios.interceptors.request.clear()
+	transport.axios.interceptors.response.clear()
+
+	if (resolvedConfig.auth) {
+		transport.axios.interceptors.request.use(async (requestConfig) => {
+			const token = await resolvedConfig.auth!.getToken?.()
+			if (token) {
+				requestConfig.headers.Authorization = `${resolvedConfig.auth!.tokenPrefix ?? 'Bearer'} ${token}`
+			}
+			return requestConfig
+		})
+	}
+	if (resolvedConfig.interceptors?.request) {
+		transport.axios.interceptors.request.use(resolvedConfig.interceptors.request)
+	}
+	transport.axios.interceptors.response.use(
+		(response) => {
+			transport.lastResponse.value = response
+			return resolvedConfig.interceptors?.response?.(response) ?? response
+		},
+		async (error) => {
+			if (error.response?.status === 401) {
+				await resolvedConfig.auth?.onUnauthorized?.()
+			}
+			resolvedConfig.onError?.(parseApiError(error), error)
+			throw error
+		}
+	)
+	return transport
+}
+
 /**
  * Request state for useApiRequest composable
  */

package/src/openAPITools/functionGenerator.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, it } from 'vitest'
+import { generateFunctions } from './functionGenerator'
+
+describe('generateFunctions transport bindings', () => {
+	it('preserves direct exports and emits transport-bound client factories', () => {
+		const code = generateFunctions({
+			'/items': {
+				get: {
+					responses: {
+						'200': {
+							description: 'OK',
+							content: {
+								'application/json': {
+									schema: { type: 'array', items: { type: 'string' } },
+								},
+							},
+						},
+					},
+				},
+			},
+			'/events': {
+				get: {
+					responses: {
+						'200': {
+							description: 'SSE',
+							content: {
+								'text/event-stream': {
+									schema: { type: 'string' },
+								},
+							},
+						},
+					},
+				},
+			},
+		}, '/api')
+
+		expect(code).toContain('export function createApiClient(transport: ApiTransport)')
+		expect(code).toContain('export const items = defaultBindings.items')
+		expect(code).toContain('export const axios = defaultTransport.axios')
+		expect(code).toContain('__transport.axios.get')
+		expect(code).toContain('__transport.createSSEStream')
+		expect(code).toContain('return defaultTransport.getStreamBaseURL()')
+	})
+})

package/src/openAPITools/functionGenerator.ts

@@ -419,8 +419,6 @@ function generateStreamFunction(
 	// const paramNames = allParams ? allParams.match(/\w+(?=\s*[?:])/g) || [] : []
 
 	const bodyVar = requestBodyPayload || '{}'
-	const baseUrlRef = 'getStreamBaseURL()'
-
 	// Generate type name for this stream
 	const streamTypeName = generateStreamTypeName(path)
 
@@ -441,12 +439,6 @@ function generateStreamFunction(
 		? `StreamController<${streamTypeName}>`
 		: 'StreamController'
 
-	// Convert formattedPath from string representation to actual path for URL construction
-	// formattedPath can be either 'path' or `path/${param}` (as strings)
-	const pathForUrl = formattedPath.startsWith('`')
-		? formattedPath.slice(1, -1) // Remove backticks to get the content
-		: formattedPath.slice(1, -1) // Remove quotes to get the content
-
 	const streamParams = allParams ? `${allParams}, options?: SSEStreamOptions` : `options?: SSEStreamOptions`
 	const regularParams = allParams
 
@@ -464,14 +456,13 @@ function generateStreamFunction(
    * stream.close()
    */
   stream: (${streamParams}): ${typeAnnotation} => {
-    const url = \`\${${baseUrlRef}}${pathForUrl}\`
-    return createSSEStreamPost<${streamTypeName}>(url, ${bodyVar}, options)
+    return __transport.createSSEStreamPost<${streamTypeName}>(${formattedPath}, ${bodyVar}, options)
   },
   /**
    * Regular POST request (non-streaming)
    */
   post: async (${regularParams}): Promise<AxiosResponse<any>> => {
-    return axios.post(${formattedPath}, ${bodyVar})
+    return __transport.axios.post(${formattedPath}, ${bodyVar})
   }
 }`
 	} else {
@@ -500,8 +491,8 @@ function generateStreamFunction(
 
 		// For GET streams with query params, build URL with suffix; otherwise plain URL
 		const urlLine = queryParams?.length
-			? `const url = \`\${${baseUrlRef}}${pathForUrl}\` + __qsSuffix`
-			: `const url = \`\${${baseUrlRef}}${pathForUrl}\``
+			? `const url = ${formattedPath} + __qsSuffix`
+			: `const url = ${formattedPath}`
 
 		const streamBody = queryParams?.length
 			? `\n    ${queryStringCode}\n    ${urlLine}`
@@ -520,13 +511,13 @@ function generateStreamFunction(
    * stream.close()
    */
   stream: (${streamParams}): ${typeAnnotation} => {${streamBody}
-    return createSSEStream<${streamTypeName}>(url, options)
+    return __transport.createSSEStream<${streamTypeName}>(url, options)
   },
   /**
    * Regular GET request (non-streaming)
    */
   get: async (${regularParams}): Promise<AxiosResponse<any>> => {
-    return axios.get(${formattedPath}${regularParamStr})
+    return __transport.axios.get(${formattedPath}${regularParamStr})
   }
 }`
 	}
@@ -574,7 +565,7 @@ function generateAxiosFunction(
         const formData = new FormData()
         formData.append('file', file)
 		formData.append('upload', file)
-        const response = await axios.${method}(${formattedPath}, formData, {
+        const response = await __transport.axios.${method}(${formattedPath}, formData, {
             headers: { 'Content-Type': 'multipart/form-data' },
             onUploadProgress: options?.onUploadProgress${paramStr ? `, ${paramStr}` : ''}
         })
@@ -582,7 +573,7 @@ function generateAxiosFunction(
 		} else {
 			// Generic FormData handling
 			axiosFunction += `
-        const response = await axios.${method}(${formattedPath}, formData, {
+        const response = await __transport.axios.${method}(${formattedPath}, formData, {
             headers: { 'Content-Type': 'multipart/form-data' }${paramStr ? `, ${paramStr}` : ''}
         })
         return ${returnExpression}`
@@ -591,7 +582,7 @@ function generateAxiosFunction(
 		const configParams = paramStr ? `, { ${paramStr} }` : ''
 		const bodyVar = requestBodyPayload || '{}'
 		axiosFunction += `
-        const response = await axios.${method}(${formattedPath}${
+        const response = await __transport.axios.${method}(${formattedPath}${
 			['get', 'delete'].includes(method)
 				? configParams
 				: `, ${bodyVar}${configParams}`
@@ -847,9 +838,22 @@ function handlePathSegment(
  * @param baseUrl - The base URL for the API
  * @returns The generated TypeScript code
  */
-export function generateFunctions(paths: OpenAPIPaths, baseUrl: string): string {
+function generateFunctionsInternal(
+	paths: OpenAPIPaths,
+	baseUrl: string,
+	moduleFactoryName?: string,
+): string {
+	// Generation can run more than once in the same process (for example, one
+	// invocation per explicitly owned module). Keep each result independent.
+	allTypes.length = 0
+	pathOperations.length = 0
+	for (const inventory of [functionsInventory, streamEventTypes, streamEventInfo, streamEventSchemas]) {
+		for (const key of Object.keys(inventory)) delete inventory[key]
+	}
+
 	const body: Record<string, any> = {}
 	const allPathsClean = Object.keys(paths).map(cleanPath)
+	const httpMethods = new Set(['get', 'put', 'post', 'delete', 'options', 'head', 'patch', 'trace'])
 
 	// Process all paths to generate functions
 	for (const [path, operation] of Object.entries(paths)) {
@@ -859,7 +863,9 @@ export function generateFunctions(paths: OpenAPIPaths, baseUrl: string): string
 			const objFuncKey = toCamelCaseSafe(key)
 			if (!objFuncKey) { return acc }
 
-			const methods = Object.keys(operation) as Array<keyof OpenAPIPath>
+			const methods = Object.keys(operation)
+				.filter(method => httpMethods.has(method)) as Array<keyof OpenAPIPath>
+			if (methods.length === 0) return acc
 			const currentPathClean = cleanPath(path)
 			const currentPathPrefix = splitPath.slice(0, index + 1).join('/')
 
@@ -899,7 +905,7 @@ export function generateFunctions(paths: OpenAPIPaths, baseUrl: string): string
 	}
 
 	// Generate TypeScript code from processed paths
-	let tsString = ''
+	let tsString = 'function createEndpointNamespaces(__transport: ApiTransport) {\n'
 	const apiObjectEntries: string[] = []
 
 	// Convert object structure to TypeScript
@@ -908,7 +914,7 @@ export function generateFunctions(paths: OpenAPIPaths, baseUrl: string): string
 /**
  * API functions for ${parent} endpoints
  */
-export const ${parent} = ${JSON.stringify(object, undefined, 2)};\n`
+const ${parent} = ${JSON.stringify(object, undefined, 2)};\n`
 		apiObjectEntries.push(parent)
 	}
 
@@ -917,9 +923,11 @@ export const ${parent} = ${JSON.stringify(object, undefined, 2)};\n`
 /**
  * Aggregated API object containing all endpoints
  */
-export const api = {
+const api = {
 ${apiObjectEntries.map(name => `	${name},`).join('\n')}
-};\n`
+};
+return { api, ${apiObjectEntries.join(', ')} }
+}\n`
 
 	// Replace placeholders with actual function bodies
 	Object.entries(functionsInventory).forEach(([key, value]) => {
@@ -927,7 +935,22 @@ ${apiObjectEntries.map(name => `	${name},`).join('\n')}
 	})
 
 	// Generate the final TypeScript file
-	return fileTemplate(tsString, allTypes, baseUrl)
+	return moduleFactoryName
+		? moduleFileTemplate(tsString, allTypes, moduleFactoryName)
+		: fileTemplate(tsString, allTypes, baseUrl, apiObjectEntries)
+}
+
+export function generateFunctions(paths: OpenAPIPaths, baseUrl: string): string {
+	return generateFunctionsInternal(paths, baseUrl)
+}
+
+/** Generate a transport-bound module client without legacy singleton state. */
+export function generateModuleFunctions(
+	paths: OpenAPIPaths,
+	baseUrl: string,
+	moduleFactoryName: string,
+): string {
+	return generateFunctionsInternal(paths, baseUrl, moduleFactoryName)
 }
 
 /**
@@ -1018,26 +1041,23 @@ function generateStreamEventTypeDefinitions(): string {
 function fileTemplate(
 	tsString: string,
 	typeForImport: string[],
-	baseURL: string
+	baseURL: string,
+	apiObjectEntries: string[]
 ): string {
 	const streamTypeDefs = generateStreamEventTypeDefinitions()
 
 	const hasStreamEndpoints = Object.keys(streamEventTypes).length > 0
 
-	// Determine which stream functions are actually used by checking functionsInventory
-	const allFunctionBodies = Object.values(functionsInventory).join('\n')
-	const hasGetStreams = allFunctionBodies.includes('createSSEStream<')
-	const hasPostStreams = allFunctionBodies.includes('createSSEStreamPost<')
-
 	const streamImports = hasStreamEndpoints
-		? `${hasPostStreams ? 'createSSEStreamPost, ' : ''}${hasGetStreams ? 'createSSEStream, ' : ''}type StreamController, type SSEStreamOptions,`
+		? `type StreamController, type SSEStreamOptions,`
 		: ''
 
-	const templateCode = `import ax from 'axios';
-import type { AxiosResponse } from 'axios';
+	const templateCode = `import type { AxiosResponse } from 'axios';
 import type { ${typeForImport.join(', ')} } from './types.d';
 import {
 	ApiResponse,
+	createApiTransport,
+	configureApiTransport,
 	parseApiError,
 	formatFieldErrors,
 	useApiRequest,
@@ -1052,9 +1072,10 @@ import {
 	type ApiRequestState,
 	type RequestInterceptor,
 	type ResponseInterceptor,
+	type ApiTransport,
 	type Unwrapped
 } from '@bagelink/sdk';
-import { ref, type Ref } from 'vue';
+import type { Ref } from 'vue';
 
 /**
  * Options for file upload operations
@@ -1070,22 +1091,29 @@ export interface UploadOptions {
 
 ${streamTypeDefs}
 
-/**
- * Configured axios instance for API requests
- */
-export const axios = ax.create({baseURL: '${baseURL}', withCredentials: true, paramsSerializer: { indexes: null }});
+const defaultTransport = createApiTransport({ baseURL: '${baseURL}' })
 
 ${tsString}
 
+const defaultBindings = createEndpointNamespaces(defaultTransport)
+export const api = defaultBindings.api
+${apiObjectEntries.map(name => `export const ${name} = defaultBindings.${name}`).join('\n')}
+export const axios = defaultTransport.axios
+
+/** Bind all generated endpoint namespaces to an isolated transport. */
+export function createApiClient(transport: ApiTransport) {
+	return createEndpointNamespaces(transport)
+}
+
+/** Resolve the default client's SSE base URL. */
+export function getStreamBaseURL(): string {
+	return defaultTransport.getStreamBaseURL()
+}
+
 // ============================================================================
 // API Instance & Configuration
 // ============================================================================
 
-/**
- * Last response metadata (accessible via useApi().$lastResponse)
- */
-const lastResponse = ref<AxiosResponse | null>(null)
-
 /**
  * API instance type with enhanced response objects
  */
@@ -1099,13 +1127,6 @@ type ApiInstance = typeof api & {
 
 // Global state
 let apiInstance: ApiInstance | null = null
-let apiConfig = ref<ApiConfig | null>(null)
-let _streamBaseURL: string | undefined
-
-/** Resolve base URL for SSE stream endpoints. Uses streamBaseURL if set, otherwise falls back to axios baseURL. */
-export function getStreamBaseURL(): string {
-	return _streamBaseURL || axios.defaults.baseURL || ""
-}
 
 /**
  * Create and configure the API instance
@@ -1113,77 +1134,17 @@ export function getStreamBaseURL(): string {
  * @returns Configured API instance
  */
 export function createApi(config: ApiConfig = {}): ApiInstance {
-	// Store config for access via useApi().$config
-	apiConfig.value = config
-
-	// Configure axios defaults
-	if (config.baseURL) {
-		axios.defaults.baseURL = config.baseURL
-	}
-	_streamBaseURL = config.streamBaseURL
-	if (config.withCredentials !== undefined) {
-		axios.defaults.withCredentials = config.withCredentials
-	}
-	if (config.axiosConfig) {
-		Object.assign(axios.defaults, config.axiosConfig)
-	}
-
-	// Clear existing interceptors
-	axios.interceptors.request.clear()
-	axios.interceptors.response.clear()
-
-	// Setup auth interceptor
-	if (config.auth) {
-		axios.interceptors.request.use(async (reqConfig) => {
-			const token = await config.auth!.getToken?.()
-			if (token) {
-				const prefix = config.auth!.tokenPrefix ?? 'Bearer'
-				reqConfig.headers.Authorization = \`\${prefix} \${token}\`
-			}
-			return reqConfig
-		})
-	}
-
-	// Setup custom request interceptor
-	if (config.interceptors?.request) {
-		axios.interceptors.request.use(config.interceptors.request)
-	}
-
-	// Setup response interceptor for error handling
-	axios.interceptors.response.use(
-		(response) => {
-			// Store last response for metadata access
-			lastResponse.value = response
-			
-			// Apply custom response interceptor if provided
-			if (config.interceptors?.response) {
-				return config.interceptors.response(response)
-			}
-			return response
-		},
-		async (error) => {
-			// Handle 401 Unauthorized
-			if (error.response?.status === 401) {
-				await config.auth?.onUnauthorized?.()
-			}
-
-			// Parse and handle error
-			const parsedError = parseApiError(error)
-			config.onError?.(parsedError, error)
-
-			throw error
-		}
-	)
+	configureApiTransport(defaultTransport, config)
 
 	// API already returns ApiResponse directly!
 	// Just add the special properties
 	apiInstance = {
 		...api,
 		$raw: api,
-		$lastResponse: lastResponse,
+		$lastResponse: defaultTransport.lastResponse,
 		$axios: axios,
 		$ApiResponse: ApiResponse,
-		$config: apiConfig
+		$config: defaultTransport.config
 	} as ApiInstance
 
 	return apiInstance
@@ -1232,3 +1193,43 @@ export {
 	// Remove potential double quotes around property names
 	return templateCode.replace(/"([^"]+)":/g, '$1:')
 }
+
+function moduleFileTemplate(
+	tsString: string,
+	typeForImport: string[],
+	moduleFactoryName: string,
+): string {
+	const streamTypeDefs = generateStreamEventTypeDefinitions()
+	const hasStreamEndpoints = Object.keys(streamEventTypes).length > 0
+	const streamImports = hasStreamEndpoints
+		? 'type StreamController, type SSEStreamOptions,'
+		: ''
+	const typeImport = typeForImport.length
+		? `import type { ${typeForImport.join(', ')} } from './types.d';`
+		: ''
+
+	const templateCode = `${typeImport}
+import {
+\tApiResponse,
+\t${streamImports}
+\ttype ApiTransport
+} from '@bagelink/sdk';
+
+export interface UploadOptions {
+\tonUploadProgress?: (progressEvent: any) => void
+\tdirPath?: string
+\ttags?: string[]
+}
+
+${streamTypeDefs}
+
+${tsString}
+
+/** Bind this module's generated endpoint namespaces to the app transport. */
+export function ${moduleFactoryName}(transport: ApiTransport) {
+\treturn createEndpointNamespaces(transport)
+}
+`
+
+	return templateCode.replace(/"([^"]+)":/g, '$1:')
+}

package/src/openAPITools/index.ts

@@ -37,4 +37,5 @@ export default async (openApiUrl: string, baseUrl: string): Promise<OpenAPIRespo
 
 export * from './streamClient'
 export * from './streamDetector'
+export * from './moduleGenerator'
 export * from './types'