@bagelink/sdk 1.15.558 → 1.15.565

package/src/openAPITools/moduleGenerator.test.ts

@@ -0,0 +1,89 @@
+import type { ModuleOwnershipManifest, OpenAPIObject } from './index'
+import { describe, expect, it } from 'vitest'
+import { generateModules, validateOwnershipManifest } from './moduleGenerator'
+
+const spec: OpenAPIObject = {
+	openapi: '3.1.0',
+	info: { title: 'test', version: '1' },
+	paths: {
+		'/person': {
+			get: {
+				tags: ['person'],
+				responses: {
+					'200': {
+						description: 'ok',
+						content: { 'application/json': { schema: { type: 'array', items: { $ref: '#/components/schemas/PersonRead' } } } },
+					},
+				},
+			},
+		},
+		'/person/{id}/notes': {
+			get: {
+				tags: ['notes'],
+				responses: { '200': { description: 'ok' } },
+			},
+		},
+	},
+	components: {
+		schemas: {
+			PersonRead: { type: 'object', properties: { address: { $ref: '#/components/schemas/Address' } } },
+			Address: { type: 'object', properties: { city: { type: 'string' } } },
+		},
+	},
+}
+
+const manifest: ModuleOwnershipManifest = {
+	version: 1,
+	modules: [
+		{ name: 'notes', tags: ['notes'] },
+		{ name: 'person', tags: ['person'] },
+	],
+}
+
+describe('explicit module generation', () => {
+	it('generates deterministic modules with transitive types', () => {
+		const generated = generateModules(spec, manifest, '/api')
+		expect(generated.map(module => module.name)).toEqual(['notes', 'person'])
+		expect(generated[1].schemas).toEqual(['Address', 'PersonRead'])
+		expect(generated[1].code).toContain('export function createPersonApi(transport: ApiTransport)')
+		expect(generated[1].code).not.toContain('createApiTransport')
+		expect(generated[1].code).not.toContain('export const axios')
+		expect(generated[1].types).toContain('export type Address')
+		expect(generated[0].code).toContain('@endpoint GET /person/{id}/notes')
+		expect(generated[0].code).not.toContain('@endpoint GET /person\n')
+	})
+
+	it('copies path parameters only into the owning module', () => {
+		const withPathParameters: OpenAPIObject = {
+			...spec,
+			paths: {
+				...spec.paths,
+				'/person/{id}': {
+					parameters: [{ name: 'id', in: 'path', required: true, schema: { type: 'string' } }],
+					get: {
+						tags: ['person'],
+						responses: { '200': { description: 'ok' } },
+					},
+				},
+			},
+		}
+
+		const generated = generateModules(withPathParameters, manifest, '/api')
+		expect(generated.find(module => module.name === 'person')?.code).toContain('axios.get(`/person/${id}`)')
+		expect(generated.find(module => module.name === 'notes')?.code).not.toContain('axios.get(`/person/${id}`)')
+	})
+
+	it('reports unowned and multiply-owned operations', () => {
+		const invalid: ModuleOwnershipManifest = {
+			version: 1,
+			modules: [
+				{ name: 'one', tags: ['person'] },
+				{ name: 'two', tags: ['person'] },
+			],
+		}
+		expect(validateOwnershipManifest(spec, invalid).map(issue => issue.kind)).toEqual([
+			'multiply-owned-operation',
+			'unowned-operation',
+		])
+	})
+})

package/src/openAPITools/moduleGenerator.ts

@@ -0,0 +1,174 @@
+import type {
+	OpenAPIObject,
+	OperationObject,
+	PathItemObject,
+	PathsObject,
+	ReferenceObject,
+	SchemaObject,
+} from './types'
+import { generateModuleFunctions } from './functionGenerator'
+import { generateTypes } from './typeGenerator'
+import { formatType } from './utils'
+
+const METHODS = ['get', 'put', 'post', 'delete', 'options', 'head', 'patch', 'trace'] as const
+
+export interface ModuleOwnership {
+	/** Stable module id and generated directory name. */
+	name: string
+	/** Exact OpenAPI tags owned by this module. */
+	tags?: string[]
+	/** Exact path prefixes owned by this module. */
+	pathPrefixes?: string[]
+	/** Explicit component schema names additionally owned by this module. */
+	schemas?: string[]
+}
+
+export interface ModuleOwnershipManifest {
+	version: 1
+	modules: ModuleOwnership[]
+}
+
+export interface ModuleGenerationResult {
+	name: string
+	paths: string[]
+	schemas: string[]
+	code: string
+	types: string
+}
+
+export interface ConformanceIssue {
+	kind: 'invalid-manifest' | 'unowned-operation' | 'multiply-owned-operation' | 'unknown-schema'
+	message: string
+}
+
+function isReference(value: unknown): value is ReferenceObject {
+	return Boolean(value && typeof value === 'object' && '$ref' in value)
+}
+
+function operationOwners(path: string, operation: OperationObject, manifest: ModuleOwnershipManifest) {
+	return manifest.modules.filter(module =>
+		module.pathPrefixes?.some(prefix => path === prefix || path.startsWith(`${prefix}/`))
+		|| operation.tags?.some(tag => module.tags?.includes(tag)),
+	)
+}
+
+function collectSchemaRefs(value: unknown, refs: Set<string>): void {
+	if (!value || typeof value !== 'object') return
+	if (isReference(value) && value.$ref.startsWith('#/components/schemas/')) {
+		refs.add(value.$ref.slice('#/components/schemas/'.length))
+	}
+	for (const child of Object.values(value)) collectSchemaRefs(child, refs)
+}
+
+function schemaClosure(openApi: OpenAPIObject, seed: Iterable<string>): string[] {
+	const schemas = openApi.components?.schemas ?? {}
+	const result = new Set(seed)
+	const pending = [...result]
+	while (pending.length) {
+		const name = pending.pop()!
+		const schema = schemas[name]
+		if (!schema) continue
+		const refs = new Set<string>()
+		collectSchemaRefs(schema, refs)
+		for (const ref of refs) {
+			if (!result.has(ref)) {
+				result.add(ref)
+				pending.push(ref)
+			}
+		}
+	}
+	return [...result].sort()
+}
+
+function moduleFactoryName(name: string): string {
+	return `create${name
+		.split('-')
+		.filter(Boolean)
+		.map(part => part[0]!.toUpperCase() + part.slice(1))
+		.join('')}Api`
+}
+
+export function validateOwnershipManifest(
+	openApi: OpenAPIObject,
+	manifest: ModuleOwnershipManifest,
+): ConformanceIssue[] {
+	const issues: ConformanceIssue[] = []
+	if (manifest.version !== 1) {
+		issues.push({ kind: 'invalid-manifest', message: `Unsupported manifest version: ${manifest.version}` })
+	}
+	const names = manifest.modules.map(module => module.name)
+	for (const name of new Set(names.filter((name, index) => names.indexOf(name) !== index))) {
+		issues.push({ kind: 'invalid-manifest', message: `Duplicate module name: ${name}` })
+	}
+	const schemas = openApi.components?.schemas ?? {}
+	for (const module of manifest.modules) {
+		if (!module.name || !/^[a-z][a-z0-9-]*$/.test(module.name)) {
+			issues.push({ kind: 'invalid-manifest', message: `Invalid module name: ${module.name || '(empty)'}` })
+		}
+		if (!(module.tags?.length || module.pathPrefixes?.length)) {
+			issues.push({ kind: 'invalid-manifest', message: `Module ${module.name} must own tags or pathPrefixes` })
+		}
+		for (const schema of module.schemas ?? []) {
+			if (!schemas[schema]) issues.push({ kind: 'unknown-schema', message: `Module ${module.name} owns unknown schema ${schema}` })
+		}
+	}
+	for (const [path, item] of Object.entries(openApi.paths ?? {})) {
+		for (const method of METHODS) {
+			const operation = item[method]
+			if (!operation) continue
+			const owners = operationOwners(path, operation, manifest)
+			if (owners.length === 0) {
+				issues.push({ kind: 'unowned-operation', message: `${method.toUpperCase()} ${path} is not owned` })
+			}
+			else if (owners.length > 1) {
+				issues.push({
+					kind: 'multiply-owned-operation',
+					message: `${method.toUpperCase()} ${path} is owned by ${owners.map(owner => owner.name).join(', ')}`,
+				})
+			}
+		}
+	}
+	return issues
+}
+
+export function generateModules(
+	openApi: OpenAPIObject,
+	manifest: ModuleOwnershipManifest,
+	baseUrl: string,
+): ModuleGenerationResult[] {
+	const issues = validateOwnershipManifest(openApi, manifest)
+	if (issues.length) throw new Error(issues.map(issue => issue.message).join('\n'))
+	const schemas = openApi.components?.schemas ?? {}
+
+	return [...manifest.modules]
+		.sort((a, b) => a.name.localeCompare(b.name))
+		.map((module) => {
+			const paths: PathsObject = {}
+			const refs = new Set(module.schemas ?? [])
+			for (const [path, item] of Object.entries(openApi.paths ?? {})) {
+				const ownedItem: PathItemObject = {}
+				for (const method of METHODS) {
+					const operation = item[method]
+					if (operation && operationOwners(path, operation, manifest)[0]?.name === module.name) {
+						;(ownedItem as Record<string, unknown>)[method] = operation
+						collectSchemaRefs(operation, refs)
+					}
+				}
+				if (Object.keys(ownedItem).length) {
+					if (item.parameters) ownedItem.parameters = item.parameters
+					paths[path] = ownedItem
+				}
+			}
+			const ownedSchemas = schemaClosure(openApi, refs)
+			const subset = Object.fromEntries(
+				ownedSchemas.map(name => [name, schemas[name]]).filter((entry): entry is [string, SchemaObject | ReferenceObject] => Boolean(entry[1])),
+			)
+			return {
+				name: module.name,
+				paths: Object.keys(paths).sort(),
+				schemas: ownedSchemas.map(formatType),
+				code: generateModuleFunctions(paths, baseUrl, moduleFactoryName(module.name)),
+				types: generateTypes(subset),
+			}
+		})
+}

package/src/openAPITools/streamClient.ts

@@ -11,7 +11,7 @@ export { StreamController, type StreamEventMap } from './StreamController'
 
 export interface SSEStreamOptions {
 	/** Additional headers to send with the request */
-	headers?: Record<string, string>
+	headers?: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>)
 	/** Whether to include credentials (cookies) with the request */
 	withCredentials?: boolean
 	/**
@@ -30,6 +30,10 @@ export interface SSEStreamOptions {
 	reconnectDelayMs?: number
 }
 
+async function resolveHeaders(headers: SSEStreamOptions['headers']): Promise<Record<string, string>> {
+	return typeof headers === 'function' ? await headers() : (headers ?? {})
+}
+
 /**
  * Creates an SSE stream consumer with elegant event-based API
  * @param url - The SSE endpoint URL
@@ -52,7 +56,7 @@ export function createSSEStream<TEventMap extends StreamEventMap = StreamEventMa
 	options: SSEStreamOptions = {}
 ): StreamController<TEventMap> {
 	const {
-		headers = {},
+		headers,
 		withCredentials = true,
 		lastEventId: initialLastEventId,
 		maxReconnects = 5,
@@ -67,10 +71,11 @@ export function createSSEStream<TEventMap extends StreamEventMap = StreamEventMa
 
 	async function connect(): Promise<void> {
 		if (controller.signal.aborted) return
+		const resolvedHeaders = await resolveHeaders(headers)
 		const requestHeaders: Record<string, string> = {
 			'Accept': 'text/event-stream',
 			'Cache-Control': 'no-cache',
-			...headers,
+			...resolvedHeaders,
 		}
 		if (lastEventId !== undefined) {
 			requestHeaders['Last-Event-ID'] = lastEventId
@@ -213,26 +218,27 @@ export function createSSEStreamPost<TEventMap extends StreamEventMap = StreamEve
 	body: TBody,
 	options: SSEStreamOptions = {}
 ): StreamController<TEventMap> {
-	const { headers = {}, withCredentials = true } = options
+	const { headers, withCredentials = true } = options
 	const controller = new AbortController()
 
 	const stream = new StreamController<TEventMap>(() => { controller.abort() })
 
-	// Start the fetch request
-	fetch(url, {
-		method: 'POST',
-		headers: {
-			'Accept': 'text/event-stream',
-			'Content-Type': 'application/json',
-			'Cache-Control': 'no-cache',
-			...headers,
-		},
-		credentials: withCredentials ? 'include' : 'same-origin',
-		body: JSON.stringify(body),
-		signal: controller.signal,
-		// Disable keepalive for streaming
-		keepalive: false,
-	})
+	// Resolve headers inside the request so async auth providers work for SSE too.
+	resolveHeaders(headers)
+		.then(resolvedHeaders => fetch(url, {
+			method: 'POST',
+			headers: {
+				'Accept': 'text/event-stream',
+				'Content-Type': 'application/json',
+				'Cache-Control': 'no-cache',
+				...resolvedHeaders,
+			},
+			credentials: withCredentials ? 'include' : 'same-origin',
+			body: JSON.stringify(body),
+			signal: controller.signal,
+			// Disable keepalive for streaming
+			keepalive: false,
+		}))
 		.then(async (response) => {
 			if (!response.ok) {
 				throw new Error(`HTTP ${response.status}: ${response.statusText}`)

package/src/transport.test.ts

@@ -0,0 +1,71 @@
+import type { AxiosAdapter } from 'axios'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { createApiTransport } from './index'
+
+afterEach(() => {
+	vi.unstubAllGlobals()
+})
+
+describe('createApiTransport', () => {
+	it('keeps Axios configuration isolated per transport', async () => {
+		const requests: Array<{ baseURL?: string, authorization?: string }> = []
+		const adapter: AxiosAdapter = async (config) => {
+			requests.push({
+				baseURL: config.baseURL,
+				authorization: config.headers.get('Authorization') as string | undefined,
+			})
+			return { config, data: {}, headers: {}, status: 200, statusText: 'OK' }
+		}
+		const first = createApiTransport({
+			baseURL: 'https://first.example/api',
+			auth: { getToken: () => 'first-token' },
+			axiosConfig: { adapter },
+		})
+		const second = createApiTransport({
+			baseURL: 'https://second.example/api',
+			auth: { getToken: () => 'second-token', tokenPrefix: 'Token' },
+			axiosConfig: { adapter },
+		})
+
+		await first.axios.get('/items')
+		await second.axios.get('/items')
+
+		expect(requests).toEqual([
+			{ baseURL: 'https://first.example/api', authorization: 'Bearer first-token' },
+			{ baseURL: 'https://second.example/api', authorization: 'Token second-token' },
+		])
+	})
+
+	it('applies transport auth, headers, credentials, and stream base URL to SSE', async () => {
+		let request: { url: string, init: RequestInit } | undefined
+		vi.stubGlobal('fetch', vi.fn(async (url: string, init: RequestInit) => {
+			request = { url, init }
+			return new Response(new ReadableStream({
+				start(controller) {
+					controller.enqueue(new TextEncoder().encode('event: done\ndata: {}\n\n'))
+					controller.close()
+				},
+			}), { status: 200 })
+		}))
+		const transport = createApiTransport({
+			baseURL: '/api',
+			streamBaseURL: 'https://streams.example',
+			withCredentials: false,
+			auth: { getToken: async () => 'secret' },
+			axiosConfig: { headers: { 'X-Client': 'sdk' } },
+		})
+
+		transport.createSSEStreamPost('/events', { message: 'hello' }, {
+			headers: { 'X-Request': 'stream' },
+		})
+		await vi.waitFor(() => expect(request).toBeDefined())
+
+		expect(request?.url).toBe('https://streams.example/events')
+		expect(request?.init.credentials).toBe('same-origin')
+		expect(request?.init.headers).toMatchObject({
+			Authorization: 'Bearer secret',
+			'X-Client': 'sdk',
+			'X-Request': 'stream',
+		})
+	})
+})