@taico/openapi-sdkgen 0.1.0

package/README.md

@@ -0,0 +1,206 @@
+# @taico/openapi-sdkgen
+
+A TypeScript SDK generator from OpenAPI specs with focus on developer ergonomics and maintainability.
+
+## Install
+
+```bash
+npm install @taico/openapi-sdkgen
+```
+
+## CLI
+
+```bash
+openapi-sdkgen ./openapi.json ./generated
+```
+
+## Motivation
+
+The existing `@taico/client` package uses `openapi-typescript-codegen` with multiple post-processing scripts to work around limitations:
+- `fix-esm-imports.js` - Adds `.js` extensions for ESM compatibility
+- `make-client-instantiable.js` - Transforms static methods to accept per-instance config
+
+This approach is fragile and hard to maintain. This package generates better SDKs from scratch instead.
+
+## Design Goals
+
+1. **Instance-based configuration** - No global singletons, auth per client instance
+2. **Ergonomic API** - Resource-based grouping, clean method signatures
+3. **Type-safe** - Full TypeScript support with strict mode
+4. **Streaming support** - SSE endpoints return AsyncIterable
+5. **Simple generator** - Transparent code generation, easy to debug
+6. **No post-processing** - Generate correct code from the start
+
+## Architecture
+
+### Three-Step Process
+
+1. **Parse** (`parser.ts`) - Convert OpenAPI JSON to internal IR
+2. **Generate** (`generator.ts`) - Produce TypeScript source files
+3. **Emit** (`index.ts`) - Write files to disk
+
+### Generated Structure
+
+```
+generated/
+├── index.ts              # Main exports
+├── client.ts             # ApiClient main class
+├── base-client.ts        # BaseClient with fetch wrapper
+├── types.ts              # Type definitions from schemas
+├── users-resource.ts     # UsersResource class
+├── tasks-resource.ts     # TasksResource class
+└── stream-resource.ts    # StreamResource class
+```
+
+### Usage Pattern
+
+```typescript
+const client = new ApiClient({
+  baseUrl: 'http://localhost:3000',
+  getAccessToken: async () => getToken(),
+});
+
+// Resource-based API
+await client.users.getUser({ id: '123' });
+await client.tasks.create({ body: { title: 'Task' } });
+
+// Streaming
+for await (const event of client.stream.events({ count: 10 })) {
+  console.log(event);
+}
+
+// AbortSignal support
+const controller = new AbortController();
+await client.users.list({ signal: controller.signal });
+```
+
+## Key Features
+
+### Instance-Based Auth
+
+```typescript
+const client1 = new ApiClient({ baseUrl: 'http://api1.com', getAccessToken: () => token1 });
+const client2 = new ApiClient({ baseUrl: 'http://api2.com', getAccessToken: () => token2 });
+```
+
+No global state, no singleton issues.
+
+### Resource Grouping
+
+Operations are grouped by OpenAPI tags into resource classes:
+- `client.users.*` - All user operations
+- `client.tasks.*` - All task operations
+- `client.stream.*` - All streaming operations
+
+### Streaming Support
+
+SSE endpoints automatically detected and generated as async generators:
+
+```typescript
+async *streamEvents(params): AsyncIterable<Event> {
+  yield* this.streamEvents('/stream/events', { params });
+}
+```
+
+### Type Safety
+
+- Request bodies typed from `requestBody` schema
+- Path/query params typed from `parameters`
+- Response types from `responses[200].content`
+- Optional fields handled correctly
+- Enums generated as union types
+
+## Testing
+
+The test suite is fully automated and self-contained under `test/`.
+
+```bash
+npm test
+```
+
+This runs the full pipeline:
+1. **Clean** - Remove previously generated client
+2. **Generate spec** - Start the test API in spec-generation mode, write `openapi.json`, exit
+3. **Generate client** - Run the generator against the spec
+4. **Run tests** - Start the test API server, run the test SDK against it, shut down
+
+### Test API (`test/api/`)
+
+NestJS app with endpoints exercising OpenAPI features:
+- GET with path/query params
+- POST/PUT/PATCH with JSON body
+- DELETE with no content response
+- Nested objects and arrays
+- Optional fields
+- SSE streaming (`/stream/events`)
+- Auth headers and custom header parameters
+- Query parameters with special characters
+
+The test API generates `openapi.json` via `--generate-spec` mode (starts, writes file, exits immediately — no server needed).
+
+### Test Client (`test/client/`)
+
+`test-sdk.ts` imports the generated SDK and makes real HTTP calls to the test API, validating both types and runtime behavior including streaming and AbortSignal.
+
+## Tradeoffs
+
+### What We Gain
+
+✅ No post-processing — generate correct code directly
+✅ Cleaner code — no regex hacks on generated output
+✅ Instance config — no global singleton
+✅ Better DX — resource grouping, clear method names
+✅ Streaming — first-class AsyncIterable support
+✅ Maintainability — simple generator, easy to understand
+
+### What We Lose
+
+❌ More code — custom generator vs off-the-shelf tool
+❌ Edge cases — may not handle all OpenAPI features yet
+❌ Battle-tested — new code vs mature library
+
+### Comparison to Current Approach
+
+| Aspect | Current (`openapi-typescript-codegen`) | New Generator |
+|--------|---------------------------------------|---------------|
+| Post-processing | 2 scripts (fix-esm, make-instantiable) | None |
+| Auth pattern | Global with per-call override | Instance-based |
+| Resource grouping | Service classes | Resource classes |
+| Streaming | Not supported | AsyncIterable |
+| Maintainability | Fragile regex transforms | Transparent generation |
+
+## Limitations
+
+Current implementation doesn't handle:
+- Complex schema compositions (allOf, oneOf, anyOf)
+- Custom media types beyond JSON
+- File uploads
+- Cookie parameters
+- Complex security schemes
+
+## File Structure
+
+```
+packages/openapi-sdkgen/
+├── src/
+│   ├── types.ts       # Internal IR types
+│   ├── parser.ts      # OpenAPI -> IR
+│   ├── generator.ts   # IR -> TypeScript
+│   ├── index.ts       # Main API
+│   └── cli.ts         # CLI tool
+├── test/
+│   ├── api/           # NestJS test API (spec source)
+│   │   └── src/
+│   │       ├── main.ts
+│   │       ├── app.module.ts
+│   │       ├── users.controller.ts
+│   │       ├── tasks.controller.ts
+│   │       └── stream.controller.ts
+│   ├── client/        # Test SDK + generated output
+│   │   ├── generated/ # Generated SDK (gitignored)
+│   │   └── test-sdk.ts
+│   └── run.mjs        # Test orchestrator
+├── package.json
+├── tsconfig.json
+└── README.md
+```

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import { generate } from './index.js';
+const args = process.argv.slice(2);
+if (args.length < 2) {
+    console.error('Usage: openapi-sdkgen <input-spec.json> <output-dir>');
+    process.exit(1);
+}
+const [inputPath, outputDir] = args;
+generate({ inputPath, outputDir })
+    .then(() => {
+    console.log('✓ Client generation complete');
+})
+    .catch((error) => {
+    console.error('Error generating client:', error);
+    process.exit(1);
+});

package/dist/generator.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedSpec } from './types.js';
+export declare function generateClient(spec: ParsedSpec): Map<string, string>;

package/dist/generator.js

@@ -0,0 +1,546 @@
+export function generateClient(spec) {
+    const files = new Map();
+    // Generate types file
+    files.set('types.ts', generateTypes(spec));
+    // Generate base client
+    files.set('base-client.ts', generateBaseClient());
+    // Generate resource classes
+    for (const resource of spec.resources) {
+        files.set(`${toKebabCase(resource.tag)}-resource.ts`, generateResource(resource));
+    }
+    // Generate main client class
+    files.set('client.ts', generateMainClient(spec));
+    // Generate index
+    files.set('index.ts', generateIndex(spec));
+    return files;
+}
+function generateTypes(spec) {
+    const lines = [
+        '// Auto-generated types from OpenAPI spec',
+        '// Do not edit manually',
+        '',
+    ];
+    for (const [name, schema] of spec.schemas) {
+        lines.push(generateTypeDefinition(name, schema));
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+function generateTypeDefinition(name, schema) {
+    if (schema.type === 'object' && schema.properties) {
+        const props = [];
+        for (const [propName, propSchema] of schema.properties) {
+            const optional = !schema.required?.includes(propName);
+            const propType = schemaToTypeScript(propSchema);
+            props.push(`  ${propName}${optional ? '?' : ''}: ${propType};`);
+        }
+        return `export interface ${name} {\n${props.join('\n')}\n}`;
+    }
+    if (schema.enum) {
+        const values = schema.enum.map((v) => `'${v}'`).join(' | ');
+        return `export type ${name} = ${values};`;
+    }
+    return `export type ${name} = ${schemaToTypeScript(schema)};`;
+}
+function schemaToTypeScript(schema) {
+    if (schema.ref) {
+        return schema.ref;
+    }
+    if (schema.enum) {
+        return schema.enum.map((v) => `'${v}'`).join(' | ');
+    }
+    let baseType;
+    switch (schema.type) {
+        case 'string':
+            baseType = 'string';
+            break;
+        case 'number':
+        case 'integer':
+            baseType = 'number';
+            break;
+        case 'boolean':
+            baseType = 'boolean';
+            break;
+        case 'array':
+            baseType = schema.items ? `${schemaToTypeScript(schema.items)}[]` : 'any[]';
+            break;
+        case 'object':
+            if (schema.properties) {
+                const props = [];
+                for (const [propName, propSchema] of schema.properties) {
+                    const optional = !schema.required?.includes(propName);
+                    props.push(`${propName}${optional ? '?' : ''}: ${schemaToTypeScript(propSchema)}`);
+                }
+                baseType = `{ ${props.join('; ')} }`;
+            }
+            else {
+                baseType = 'Record<string, any>';
+            }
+            break;
+        default:
+            baseType = 'any';
+    }
+    return schema.nullable ? `${baseType} | null` : baseType;
+}
+function generateBaseClient() {
+    return `// Base client with fetch wrapper
+export interface ClientConfig {
+  baseUrl: string;
+  /** Bearer token auth: sets Authorization: Bearer <token> */
+  getAccessToken?: () => string | Promise<string>;
+  /** Cookie auth for Node.js: sets Cookie header directly */
+  getCookies?: () => string | Promise<string>;
+  /** Cookie auth for browsers: passed as fetch credentials option (e.g. 'include') */
+  credentials?: 'include' | 'same-origin' | 'omit';
+  headers?: Record<string, string>;
+}
+
+export class BaseClient {
+  constructor(protected config: ClientConfig) {}
+
+  private async buildAuthHeaders(): Promise<Record<string, string>> {
+    const headers: Record<string, string> = {};
+    if (this.config.getAccessToken) {
+      const token = await this.config.getAccessToken();
+      headers['Authorization'] = \`Bearer \${token}\`;
+    }
+    if (this.config.getCookies) {
+      headers['Cookie'] = await this.config.getCookies();
+    }
+    return headers;
+  }
+
+  protected async request<T>(
+    method: string,
+    path: string,
+    options?: {
+      params?: Record<string, any>;
+      body?: any;
+      headers?: Record<string, string>;
+      signal?: AbortSignal;
+    }
+  ): Promise<T> {
+    const url = new URL(path, this.config.baseUrl);
+
+    // Add query parameters
+    if (options?.params) {
+      for (const [key, value] of Object.entries(options.params)) {
+        if (value !== undefined && value !== null) {
+          url.searchParams.append(key, String(value));
+        }
+      }
+    }
+
+    // Build headers (filter out undefined values)
+    const headers: Record<string, string> = {};
+
+    // Add config headers
+    if (this.config.headers) {
+      for (const [key, value] of Object.entries(this.config.headers)) {
+        if (value !== undefined && value !== null) {
+          headers[key] = String(value);
+        }
+      }
+    }
+
+    // Add request-specific headers
+    if (options?.headers) {
+      for (const [key, value] of Object.entries(options.headers)) {
+        if (value !== undefined && value !== null) {
+          headers[key] = String(value);
+        }
+      }
+    }
+
+    // Add auth headers
+    Object.assign(headers, await this.buildAuthHeaders());
+
+    // Add content type for body requests
+    if (options?.body && !headers['Content-Type']) {
+      headers['Content-Type'] = 'application/json';
+    }
+
+    const response = await fetch(url.toString(), {
+      method,
+      headers,
+      body: options?.body ? JSON.stringify(options.body) : undefined,
+      signal: options?.signal,
+      credentials: this.config.credentials,
+    });
+
+    if (!response.ok) {
+      throw new Error(\`HTTP \${response.status}: \${response.statusText}\`);
+    }
+
+    // Handle no content responses
+    if (response.status === 204 || response.headers.get('content-length') === '0') {
+      return undefined as T;
+    }
+
+    const contentType = response.headers.get('content-type');
+    if (contentType?.includes('application/json')) {
+      return response.json() as Promise<T>;
+    }
+
+    return response.text() as any;
+  }
+
+  protected async *streamEvents<T = any>(
+    path: string,
+    options?: {
+      params?: Record<string, any>;
+      headers?: Record<string, string>;
+      signal?: AbortSignal;
+    }
+  ): AsyncIterable<T> {
+    const url = new URL(path, this.config.baseUrl);
+
+    if (options?.params) {
+      for (const [key, value] of Object.entries(options.params)) {
+        if (value !== undefined && value !== null) {
+          url.searchParams.append(key, String(value));
+        }
+      }
+    }
+
+    // Build headers (filter out undefined values)
+    const headers: Record<string, string> = {
+      'Accept': 'text/event-stream',
+    };
+
+    // Add config headers
+    if (this.config.headers) {
+      for (const [key, value] of Object.entries(this.config.headers)) {
+        if (value !== undefined && value !== null) {
+          headers[key] = String(value);
+        }
+      }
+    }
+
+    // Add request-specific headers
+    if (options?.headers) {
+      for (const [key, value] of Object.entries(options.headers)) {
+        if (value !== undefined && value !== null) {
+          headers[key] = String(value);
+        }
+      }
+    }
+
+    // Add auth headers
+    Object.assign(headers, await this.buildAuthHeaders());
+
+    const response = await fetch(url.toString(), {
+      method: 'GET',
+      headers,
+      signal: options?.signal,
+      credentials: this.config.credentials,
+    });
+
+    if (!response.ok) {
+      throw new Error(\`HTTP \${response.status}: \${response.statusText}\`);
+    }
+
+    if (!response.body) {
+      throw new Error('Response body is null');
+    }
+
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\\n');
+        buffer = lines.pop() || '';
+
+        for (const line of lines) {
+          if (line.startsWith('data: ')) {
+            const data = line.slice(6);
+            try {
+              yield JSON.parse(data) as T;
+            } catch {
+              yield data as T;
+            }
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+}
+`;
+}
+function generateResource(resource) {
+    // Collect all type references used in this resource
+    const typeRefs = new Set();
+    for (const op of resource.operations) {
+        // Collect types from parameters
+        for (const param of op.parameters) {
+            collectTypeRefs(param.schema, typeRefs);
+        }
+        // Collect types from request body
+        if (op.requestBody?.content) {
+            for (const [, mediaType] of op.requestBody.content) {
+                collectTypeRefs(mediaType.schema, typeRefs);
+            }
+        }
+        // Collect types from responses
+        for (const [, response] of op.responses) {
+            if (response.content) {
+                for (const [, mediaType] of response.content) {
+                    collectTypeRefs(mediaType.schema, typeRefs);
+                }
+            }
+        }
+    }
+    const lines = [
+        `import { BaseClient, ClientConfig } from './base-client.js';`,
+    ];
+    // Add type imports if any types are referenced
+    if (typeRefs.size > 0) {
+        const sortedTypes = Array.from(typeRefs).sort();
+        lines.push(`import type { ${sortedTypes.join(', ')} } from './types.js';`);
+    }
+    lines.push('');
+    lines.push(`export class ${resource.name} extends BaseClient {`);
+    lines.push(`  constructor(config: ClientConfig) {`);
+    lines.push(`    super(config);`);
+    lines.push(`  }`);
+    lines.push('');
+    for (const op of resource.operations) {
+        lines.push(generateOperation(op));
+        lines.push('');
+    }
+    lines.push('}');
+    return lines.join('\n');
+}
+function collectTypeRefs(schema, refs) {
+    if (schema.ref) {
+        refs.add(schema.ref);
+        return;
+    }
+    if (schema.type === 'array' && schema.items) {
+        collectTypeRefs(schema.items, refs);
+    }
+    if (schema.type === 'object' && schema.properties) {
+        for (const [, propSchema] of schema.properties) {
+            collectTypeRefs(propSchema, refs);
+        }
+    }
+}
+function generateOperation(op) {
+    const lines = [];
+    // Determine if this is a streaming endpoint by checking response content-type
+    const isStreaming = isStreamingEndpoint(op);
+    // Build method signature
+    // Use operationId directly as method name (already in desired format from OpenAPI)
+    const methodName = op.operationId;
+    const { params, isParamsOptional } = buildMethodParams(op);
+    const returnType = inferReturnType(op, isStreaming);
+    // Add JSDoc comment
+    if (op.summary) {
+        lines.push(`  /** ${op.summary} */`);
+    }
+    lines.push(`  async ${isStreaming ? '*' : ''}${methodName}(${params}): ${returnType} {`);
+    // Build path with path parameters
+    const pathParams = op.parameters.filter((p) => p.in === 'path');
+    let pathExpr;
+    if (pathParams.length > 0) {
+        // Use template literal for paths with parameters
+        let path = op.path;
+        for (const param of pathParams) {
+            const accessor = needsQuoting(param.name) ? `['${param.name}']` : `.${param.name}`;
+            const paramRef = isParamsOptional ? `params?${accessor}` : `params${accessor}`;
+            path = path.replace(`{${param.name}}`, `\${${paramRef}}`);
+        }
+        pathExpr = `\`${path}\``;
+    }
+    else {
+        pathExpr = `'${op.path}'`;
+    }
+    // Build query parameters
+    const queryParams = op.parameters.filter((p) => p.in === 'query');
+    const hasQueryParams = queryParams.length > 0;
+    // Build header parameters
+    const headerParams = op.parameters.filter((p) => p.in === 'header');
+    const hasHeaderParams = headerParams.length > 0;
+    // Build request options
+    const requestOptions = [];
+    const paramsPrefix = isParamsOptional ? 'params?.' : 'params.';
+    if (hasQueryParams) {
+        const queryObj = queryParams
+            .map((p) => {
+            const needsQuote = needsQuoting(p.name);
+            const quotedKey = quoteIfNeeded(p.name);
+            let paramRef;
+            if (isParamsOptional) {
+                paramRef = needsQuote ? `params?.['${p.name}']` : `params?.${p.name}`;
+            }
+            else {
+                paramRef = needsQuote ? `params['${p.name}']` : `params.${p.name}`;
+            }
+            return `${quotedKey}: ${paramRef}`;
+        })
+            .join(', ');
+        requestOptions.push(`params: { ${queryObj} }`);
+    }
+    if (hasHeaderParams) {
+        const headersObj = headerParams
+            .map((p) => {
+            const needsQuote = needsQuoting(p.name);
+            let paramRef;
+            if (isParamsOptional) {
+                paramRef = needsQuote ? `params?.['${p.name}']` : `params?.${p.name}`;
+            }
+            else {
+                paramRef = needsQuote ? `params['${p.name}']` : `params.${p.name}`;
+            }
+            return `'${p.name}': ${paramRef}`;
+        })
+            .join(', ');
+        requestOptions.push(`headers: { ${headersObj} }`);
+    }
+    if (op.requestBody) {
+        requestOptions.push(`body: ${paramsPrefix}body`);
+    }
+    if (params.includes('signal')) {
+        requestOptions.push('signal: params?.signal');
+    }
+    if (isStreaming) {
+        lines.push(`    yield* this.streamEvents(${pathExpr}${requestOptions.length > 0 ? `, { ${requestOptions.join(', ')} }` : ''});`);
+    }
+    else {
+        lines.push(`    return this.request('${op.method}', ${pathExpr}${requestOptions.length > 0 ? `, { ${requestOptions.join(', ')} }` : ''});`);
+    }
+    lines.push('  }');
+    return lines.join('\n');
+}
+function isStreamingEndpoint(op) {
+    // Check if any successful response has text/event-stream content type
+    for (const [status, response] of op.responses.entries()) {
+        if (status >= 200 && status < 300 && response.content) {
+            for (const contentType of response.content.keys()) {
+                if (contentType.includes('text/event-stream')) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+function buildMethodParams(op) {
+    const params = [];
+    // Collect all parameters
+    const pathParams = op.parameters.filter((p) => p.in === 'path');
+    const queryParams = op.parameters.filter((p) => p.in === 'query');
+    const headerParams = op.parameters.filter((p) => p.in === 'header');
+    let isParamsOptional = false;
+    if (pathParams.length > 0 || queryParams.length > 0 || headerParams.length > 0 || op.requestBody) {
+        const paramFields = [];
+        for (const param of [...pathParams, ...queryParams, ...headerParams]) {
+            const optional = !param.required;
+            const quotedName = quoteIfNeeded(param.name);
+            paramFields.push(`${quotedName}${optional ? '?' : ''}: ${schemaToTypeScript(param.schema)}`);
+        }
+        if (op.requestBody) {
+            const bodySchema = op.requestBody.content.get('application/json');
+            if (bodySchema) {
+                const optional = !op.requestBody.required;
+                paramFields.push(`body${optional ? '?' : ''}: ${schemaToTypeScript(bodySchema.schema)}`);
+            }
+        }
+        paramFields.push('signal?: AbortSignal');
+        // Check if params object should be optional (all fields are optional)
+        const hasRequiredParams = pathParams.some(p => p.required) ||
+            queryParams.some(p => p.required) ||
+            headerParams.some(p => p.required) ||
+            (op.requestBody?.required ?? false);
+        isParamsOptional = !hasRequiredParams;
+        const paramsOptional = isParamsOptional ? '?' : '';
+        params.push(`params${paramsOptional}: { ${paramFields.join('; ')} }`);
+    }
+    else {
+        params.push('params?: { signal?: AbortSignal }');
+        isParamsOptional = true;
+    }
+    return { params: params.join(', '), isParamsOptional };
+}
+function inferReturnType(op, isStreaming) {
+    const successResponse = op.responses.get(200) || op.responses.get(201);
+    if (!successResponse?.content) {
+        return isStreaming ? 'AsyncIterable<any>' : 'Promise<void>';
+    }
+    const jsonContent = successResponse.content.get('application/json');
+    if (!jsonContent) {
+        return isStreaming ? 'AsyncIterable<any>' : 'Promise<any>';
+    }
+    const tsType = schemaToTypeScript(jsonContent.schema);
+    if (isStreaming) {
+        return `AsyncIterable<${tsType}>`;
+    }
+    return `Promise<${tsType}>`;
+}
+function generateMainClient(spec) {
+    const lines = [
+        `import { ClientConfig } from './base-client.js';`,
+    ];
+    for (const resource of spec.resources) {
+        lines.push(`import { ${resource.name} } from './${toKebabCase(resource.tag)}-resource.js';`);
+    }
+    lines.push('');
+    lines.push(`export class ApiClient {`);
+    for (const resource of spec.resources) {
+        lines.push(`  public readonly ${toCamelCase(resource.tag)}: ${resource.name};`);
+    }
+    lines.push('');
+    lines.push(`  constructor(config: ClientConfig) {`);
+    for (const resource of spec.resources) {
+        lines.push(`    this.${toCamelCase(resource.tag)} = new ${resource.name}(config);`);
+    }
+    lines.push('  }');
+    lines.push('}');
+    return lines.join('\n');
+}
+function generateIndex(spec) {
+    const lines = [
+        `export { ApiClient } from './client.js';`,
+        `export type { ClientConfig } from './base-client.js';`,
+        `export * from './types.js';`,
+    ];
+    return lines.join('\n');
+}
+function toCamelCase(str) {
+    // Convert to camelCase by:
+    // 1. Replace special chars and separators with spaces
+    // 2. Split on whitespace/separators
+    // 3. Lowercase first word, capitalize rest
+    // 4. Join without spaces
+    const words = str
+        .replace(/[-_]/g, ' ') // Replace hyphens and underscores with spaces
+        .split(/\s+/) // Split on whitespace
+        .filter(word => word.length > 0); // Remove empty strings
+    if (words.length === 0)
+        return str;
+    return words[0].toLowerCase() +
+        words.slice(1)
+            .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+            .join('');
+}
+function toKebabCase(str) {
+    return str
+        .replace(/([a-z])([A-Z])/g, '$1-$2')
+        .replace(/[\s_]+/g, '-')
+        .toLowerCase();
+}
+function needsQuoting(identifier) {
+    // Check if identifier needs quoting (contains hyphens or other special chars)
+    return !/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(identifier);
+}
+function quoteIfNeeded(identifier) {
+    return needsQuoting(identifier) ? `'${identifier}'` : identifier;
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import type { GeneratorConfig } from './types.js';
+export declare function generate(config: GeneratorConfig): Promise<void>;
+export * from './types.js';
+export { parseOpenAPISpec } from './parser.js';
+export { generateClient } from './generator.js';

package/dist/index.js

@@ -0,0 +1,24 @@
+import { readFileSync, mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { parseOpenAPISpec } from './parser.js';
+import { generateClient } from './generator.js';
+export async function generate(config) {
+    // Read OpenAPI spec
+    const specContent = readFileSync(config.inputPath, 'utf-8');
+    const spec = JSON.parse(specContent);
+    // Parse spec
+    const parsed = parseOpenAPISpec(spec);
+    // Generate files
+    const files = generateClient(parsed);
+    // Write files
+    mkdirSync(config.outputDir, { recursive: true });
+    for (const [filename, content] of files) {
+        const filePath = join(config.outputDir, filename);
+        writeFileSync(filePath, content, 'utf-8');
+        console.log(`Generated: ${filePath}`);
+    }
+    console.log(`✓ Generated ${files.size} files in ${config.outputDir}`);
+}
+export * from './types.js';
+export { parseOpenAPISpec } from './parser.js';
+export { generateClient } from './generator.js';

package/dist/parser.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedSpec } from './types.js';
+export declare function parseOpenAPISpec(spec: any): ParsedSpec;

package/dist/parser.js

@@ -0,0 +1,171 @@
+export function parseOpenAPISpec(spec) {
+    const schemas = parseSchemas(spec.components?.schemas || {});
+    const operations = parseOperations(spec.paths || {});
+    // Group operations by tag
+    const resourceMap = new Map();
+    for (const op of operations) {
+        const tag = op.tags[0] || 'default';
+        if (!resourceMap.has(tag)) {
+            resourceMap.set(tag, []);
+        }
+        resourceMap.get(tag).push(op);
+    }
+    const resources = Array.from(resourceMap.entries()).map(([tag, ops]) => ({
+        name: toPascalCase(tag) + 'Resource',
+        tag,
+        operations: ops,
+    }));
+    return {
+        info: {
+            title: spec.info?.title || 'API Client',
+            version: spec.info?.version || '1.0.0',
+        },
+        resources,
+        schemas,
+    };
+}
+function parseOperations(paths) {
+    const operations = [];
+    for (const [path, pathItem] of Object.entries(paths)) {
+        // Parse path-level parameters (common to all operations on this path)
+        const pathLevelParams = parseParameters(pathItem.parameters || []);
+        for (const [method, operation] of Object.entries(pathItem)) {
+            if (!['get', 'post', 'put', 'patch', 'delete'].includes(method)) {
+                continue;
+            }
+            const op = operation;
+            // Merge path-level and operation-level parameters (operation takes precedence)
+            const opParams = parseParameters(op.parameters || []);
+            const params = [...pathLevelParams];
+            // Add operation params, overriding path-level params with same name/in combination
+            for (const opParam of opParams) {
+                const existingIndex = params.findIndex(p => p.name === opParam.name && p.in === opParam.in);
+                if (existingIndex >= 0) {
+                    params[existingIndex] = opParam; // Operation-level takes precedence
+                }
+                else {
+                    params.push(opParam);
+                }
+            }
+            // Extract path parameters from the path string if not already in parameters
+            const pathParamMatches = path.matchAll(/\{([^}]+)\}/g);
+            for (const match of pathParamMatches) {
+                const paramName = match[1];
+                // Only add if not already present
+                if (!params.find(p => p.name === paramName && p.in === 'path')) {
+                    params.push({
+                        name: paramName,
+                        in: 'path',
+                        required: true,
+                        schema: { type: 'string' },
+                    });
+                }
+            }
+            operations.push({
+                operationId: op.operationId || `${method}${path.replace(/\//g, '_')}`,
+                method: method.toUpperCase(),
+                path,
+                summary: op.summary,
+                parameters: params,
+                requestBody: op.requestBody ? parseRequestBody(op.requestBody) : undefined,
+                responses: parseResponses(op.responses || {}),
+                tags: op.tags || [],
+            });
+        }
+    }
+    return operations;
+}
+function parseParameters(parameters) {
+    return parameters.map((param) => ({
+        name: param.name,
+        in: param.in,
+        required: param.required || false,
+        schema: parseSchema(param.schema),
+        description: param.description,
+    }));
+}
+function parseRequestBody(requestBody) {
+    const content = new Map();
+    for (const [contentType, mediaType] of Object.entries(requestBody.content || {})) {
+        content.set(contentType, {
+            schema: parseSchema(mediaType.schema),
+        });
+    }
+    return {
+        required: requestBody.required || false,
+        content,
+    };
+}
+function parseResponses(responses) {
+    const result = new Map();
+    for (const [status, response] of Object.entries(responses)) {
+        const resp = response;
+        const content = new Map();
+        if (resp.content) {
+            for (const [contentType, mediaType] of Object.entries(resp.content)) {
+                content.set(contentType, {
+                    schema: parseSchema(mediaType.schema),
+                });
+            }
+        }
+        result.set(Number(status), {
+            description: resp.description || '',
+            content: content.size > 0 ? content : undefined,
+        });
+    }
+    return result;
+}
+function parseSchema(schema) {
+    if (!schema) {
+        return { type: 'any' };
+    }
+    if (schema.$ref) {
+        return {
+            type: 'ref',
+            ref: schema.$ref.replace('#/components/schemas/', ''),
+        };
+    }
+    const info = {
+        type: schema.type || 'any',
+        format: schema.format,
+        nullable: schema.nullable,
+    };
+    if (schema.enum) {
+        info.enum = schema.enum;
+    }
+    if (schema.type === 'array' && schema.items) {
+        info.items = parseSchema(schema.items);
+    }
+    if (schema.type === 'object' && schema.properties) {
+        const props = new Map();
+        for (const [propName, propSchema] of Object.entries(schema.properties)) {
+            props.set(propName, parseSchema(propSchema));
+        }
+        info.properties = props;
+        info.required = schema.required || [];
+    }
+    return info;
+}
+function parseSchemas(schemas) {
+    const result = new Map();
+    for (const [name, schema] of Object.entries(schemas)) {
+        result.set(name, parseSchema(schema));
+    }
+    return result;
+}
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function toPascalCase(str) {
+    // Convert to PascalCase by:
+    // 1. Replace special chars and separators with spaces
+    // 2. Split on whitespace/separators
+    // 3. Capitalize first letter of each word
+    // 4. Join without spaces
+    return str
+        .replace(/[-_]/g, ' ') // Replace hyphens and underscores with spaces
+        .split(/\s+/) // Split on whitespace
+        .filter(word => word.length > 0) // Remove empty strings
+        .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join('');
+}

package/dist/types.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Internal representation of OpenAPI spec for code generation
+ */
+export interface ParsedSpec {
+    info: {
+        title: string;
+        version: string;
+    };
+    resources: Resource[];
+    schemas: Map<string, SchemaInfo>;
+}
+export interface Resource {
+    name: string;
+    tag: string;
+    operations: Operation[];
+}
+export interface Operation {
+    operationId: string;
+    method: string;
+    path: string;
+    summary?: string;
+    parameters: Parameter[];
+    requestBody?: RequestBody;
+    responses: Map<number, Response>;
+    tags: string[];
+}
+export interface Parameter {
+    name: string;
+    in: 'path' | 'query' | 'header';
+    required: boolean;
+    schema: SchemaInfo;
+    description?: string;
+}
+export interface RequestBody {
+    required: boolean;
+    content: Map<string, MediaType>;
+}
+export interface MediaType {
+    schema: SchemaInfo;
+}
+export interface Response {
+    description: string;
+    content?: Map<string, MediaType>;
+}
+export interface SchemaInfo {
+    type: string;
+    format?: string;
+    items?: SchemaInfo;
+    properties?: Map<string, SchemaInfo>;
+    required?: string[];
+    enum?: string[];
+    ref?: string;
+    nullable?: boolean;
+}
+export interface GeneratorConfig {
+    inputPath: string;
+    outputDir: string;
+    clientClassName?: string;
+}

package/dist/types.js

@@ -0,0 +1,4 @@
+/**
+ * Internal representation of OpenAPI spec for code generation
+ */
+export {};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@taico/openapi-sdkgen",
+  "version": "0.1.0",
+  "type": "module",
+  "private": false,
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "package.json"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "openapi-sdkgen": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test:api": "tsx --tsconfig test/api/tsconfig.json test/api/src/main.ts",
+    "test:client": "tsx test/client/test-sdk.ts",
+    "generate:spec": "tsx --tsconfig test/api/tsconfig.json test/api/src/main.ts --generate-spec",
+    "clean": "rm -rf test/client/generated",
+    "generate": "tsx src/cli.ts test/api/openapi.json test/client/generated",
+    "lint:generated": "tsc --noEmit --project test/client/tsconfig.json",
+    "test": "npm run clean && npm run generate:spec && npm run generate && npm run lint:generated && node test/run.mjs",
+    "pack": "npm run build && npm pack",
+    "release": "npm run build && npm publish --access public"
+  },
+  "devDependencies": {
+    "@nestjs/common": "^11.0.0",
+    "@nestjs/core": "^11.0.0",
+    "@nestjs/platform-express": "^11.0.0",
+    "@nestjs/swagger": "^11.2.1",
+    "@types/node": "^20.0.0",
+    "reflect-metadata": "^0.2.0",
+    "rxjs": "^7.8.1",
+    "tsx": "^4.7.0",
+    "typescript": "^5.6.3"
+  }
+}