@pattern-stack/frontend-patterns 0.2.0-alpha.1 → 0.2.0-alpha.12

package/cli/src/codegen/openapi/client-generator.js

@@ -1,727 +0,0 @@
-/**
- * API Client Generator
- *
- * Creates a type-safe API client with interceptors and error handling
- * based on parsed OpenAPI specifications.
- *
- * Part of FRO-12: API Client Generator
- */
-import { singularize, pluralize, isPlural } from './naming-utils.js';
-import { AUTH_ACTIONS, HEALTH_ENDPOINTS, USER_PROFILE_ENDPOINTS, SINGLETON_RESOURCES, COLLECTION_ACTIONS } from './naming-constants.js';
-
-export class APIClientGenerator {
-    options;
-    constructor(options = {}) {
-        this.options = {
-            clientType: options.clientType || 'axios',
-            baseUrl: options.baseUrl || '',
-            includeAuth: options.includeAuth !== false,
-            authType: options.authType || 'bearer',
-            timeout: options.timeout || 10000,
-            retries: options.retries || 3,
-            includeInterceptors: options.includeInterceptors !== false
-        };
-    }
-    generate(parsedAPI) {
-        return {
-            client: this.generateClientSetup(),
-            methods: this.generateApiMethods(parsedAPI.endpoints),
-            types: this.generateClientTypes(),
-            config: this.generateConfiguration(),
-            index: this.generateIndexFile()
-        };
-    }
-    generateClientSetup() {
-        if (this.options.clientType === 'axios') {
-            return this.generateAxiosClient();
-        }
-        else {
-            return this.generateFetchClient();
-        }
-    }
-    generateAxiosClient() {
-        return `/**
- * Axios API Client
- *
- * Auto-generated API client with interceptors and error handling
- */
-
-import axios, { AxiosInstance, AxiosError, AxiosRequestConfig, AxiosResponse } from 'axios'
-import { APIClientConfig, RequestOptions, APIError } from './types'
-
-export class APIClient {
-  private client: AxiosInstance
-  private config: APIClientConfig
-
-  constructor(config: APIClientConfig) {
-    this.config = config
-    this.client = this.createAxiosInstance()
-    this.setupInterceptors()
-  }
-
-  private createAxiosInstance(): AxiosInstance {
-    return axios.create({
-      baseURL: this.config.baseUrl,
-      timeout: this.config.timeout || ${this.options.timeout},
-      headers: {
-        'Content-Type': 'application/json',
-        ...this.config.defaultHeaders
-      }
-    })
-  }
-
-  ${this.options.includeInterceptors ? this.generateAxiosInterceptors() : ''}
-
-  private async makeRequest<T>(
-    method: string,
-    url: string,
-    options: RequestOptions = {}
-  ): Promise<T> {
-    try {
-      const config: AxiosRequestConfig = {
-        method: method as any,
-        url,
-        ...options.config
-      }
-
-      if (options.params) {
-        config.params = options.params
-      }
-
-      if (options.data) {
-        config.data = options.data
-      }
-
-      if (options.headers) {
-        config.headers = { ...config.headers, ...options.headers }
-      }
-
-      ${this.options.includeAuth ? this.generateAuthInjection() : ''}
-
-      const response: AxiosResponse<T> = await this.client.request(config)
-      return response.data
-    } catch (error) {
-      throw this.handleError(error as AxiosError)
-    }
-  }
-
-  private handleError(error: AxiosError): APIError {
-    const apiError: APIError = {
-      message: error.message,
-      status: error.response?.status,
-      statusText: error.response?.statusText,
-      data: error.response?.data,
-      config: {
-        url: error.config?.url,
-        method: error.config?.method?.toUpperCase(),
-        headers: error.config?.headers
-      }
-    }
-
-    if (this.config.onError) {
-      this.config.onError(apiError)
-    }
-
-    return apiError
-  }
-
-  public get<T>(url: string, options?: RequestOptions): Promise<T> {
-    return this.makeRequest<T>('GET', url, options)
-  }
-
-  public post<T>(url: string, data?: any, options?: RequestOptions): Promise<T> {
-    return this.makeRequest<T>('POST', url, { ...options, data })
-  }
-
-  public put<T>(url: string, data?: any, options?: RequestOptions): Promise<T> {
-    return this.makeRequest<T>('PUT', url, { ...options, data })
-  }
-
-  public patch<T>(url: string, data?: any, options?: RequestOptions): Promise<T> {
-    return this.makeRequest<T>('PATCH', url, { ...options, data })
-  }
-
-  public delete<T>(url: string, options?: RequestOptions): Promise<T> {
-    return this.makeRequest<T>('DELETE', url, options)
-  }
-}`;
-    }
-    generateFetchClient() {
-        return `/**
- * Fetch API Client
- *
- * Auto-generated API client using native fetch with error handling
- */
-
-import { APIClientConfig, RequestOptions, APIError } from './types'
-
-export class APIClient {
-  private config: APIClientConfig
-
-  constructor(config: APIClientConfig) {
-    this.config = config
-  }
-
-  private async makeRequest<T>(
-    method: string,
-    url: string,
-    options: RequestOptions = {}
-  ): Promise<T> {
-    try {
-      const fullUrl = this.buildUrl(url, options.params)
-
-      const fetchOptions: RequestInit = {
-        method,
-        headers: {
-          'Content-Type': 'application/json',
-          ...this.config.defaultHeaders,
-          ...options.headers
-        },
-        signal: options.signal
-      }
-
-      if (options.data && method !== 'GET') {
-        fetchOptions.body = JSON.stringify(options.data)
-      }
-
-      ${this.options.includeAuth ? this.generateFetchAuthInjection() : ''}
-
-      const response = await fetch(fullUrl, fetchOptions)
-
-      if (!response.ok) {
-        throw await this.createErrorFromResponse(response)
-      }
-
-      const contentType = response.headers.get('content-type')
-      if (contentType && contentType.includes('application/json')) {
-        return await response.json()
-      }
-
-      return await response.text() as any
-    } catch (error) {
-      if (error instanceof APIError) {
-        throw error
-      }
-      throw this.createGenericError(error as Error)
-    }
-  }
-
-  private buildUrl(path: string, params?: Record<string, any>): string {
-    const url = new URL(path, this.config.baseUrl)
-
-    if (params) {
-      Object.entries(params).forEach(([key, value]) => {
-        if (value !== undefined && value !== null) {
-          url.searchParams.append(key, String(value))
-        }
-      })
-    }
-
-    return url.toString()
-  }
-
-  private async createErrorFromResponse(response: Response): Promise<APIError> {
-    let data: any
-    try {
-      data = await response.json()
-    } catch {
-      data = await response.text()
-    }
-
-    const error: APIError = {
-      message: data?.message || response.statusText || 'Request failed',
-      status: response.status,
-      statusText: response.statusText,
-      data,
-      config: {
-        url: response.url,
-        method: 'Unknown'
-      }
-    }
-
-    if (this.config.onError) {
-      this.config.onError(error)
-    }
-
-    return error
-  }
-
-  private createGenericError(error: Error): APIError {
-    const apiError: APIError = {
-      message: error.message,
-      config: {}
-    }
-
-    if (this.config.onError) {
-      this.config.onError(apiError)
-    }
-
-    return apiError
-  }
-
-  public get<T>(url: string, options?: RequestOptions): Promise<T> {
-    return this.makeRequest<T>('GET', url, options)
-  }
-
-  public post<T>(url: string, data?: any, options?: RequestOptions): Promise<T> {
-    return this.makeRequest<T>('POST', url, { ...options, data })
-  }
-
-  public put<T>(url: string, data?: any, options?: RequestOptions): Promise<T> {
-    return this.makeRequest<T>('PUT', url, { ...options, data })
-  }
-
-  public patch<T>(url: string, data?: any, options?: RequestOptions): Promise<T> {
-    return this.makeRequest<T>('PATCH', url, { ...options, data })
-  }
-
-  public delete<T>(url: string, options?: RequestOptions): Promise<T> {
-    return this.makeRequest<T>('DELETE', url, options)
-  }
-}`;
-    }
-    generateAxiosInterceptors() {
-        return `
-  private setupInterceptors(): void {
-    // Request interceptor
-    this.client.interceptors.request.use(
-      (config) => {
-        if (this.config.onRequest) {
-          return this.config.onRequest(config) || config
-        }
-        return config
-      },
-      (error) => {
-        if (this.config.onRequestError) {
-          this.config.onRequestError(error)
-        }
-        return Promise.reject(error)
-      }
-    )
-
-    // Response interceptor
-    this.client.interceptors.response.use(
-      (response) => {
-        if (this.config.onResponse) {
-          return this.config.onResponse(response) || response
-        }
-        return response
-      },
-      async (error) => {
-        if (this.config.onResponseError) {
-          const result = await this.config.onResponseError(error)
-          if (result) {
-            return result
-          }
-        }
-
-        // Auto-retry logic
-        if (this.shouldRetry(error)) {
-          return this.retryRequest(error.config)
-        }
-
-        return Promise.reject(error)
-      }
-    )
-  }
-
-  private shouldRetry(error: AxiosError): boolean {
-    const retryCount = (error.config as any)?._retryCount || 0
-    const maxRetries = this.config.retries || ${this.options.retries}
-
-    return (
-      retryCount < maxRetries &&
-      (!error.response || error.response.status >= 500) &&
-      error.code !== 'ECONNABORTED'
-    )
-  }
-
-  private async retryRequest(config: any): Promise<any> {
-    config._retryCount = (config._retryCount || 0) + 1
-
-    // Exponential backoff
-    const delay = Math.pow(2, config._retryCount) * 1000
-    await new Promise(resolve => setTimeout(resolve, delay))
-
-    return this.client.request(config)
-  }`;
-    }
-    generateAuthInjection() {
-        switch (this.options.authType) {
-            case 'bearer':
-                return `
-      // Inject bearer token if available
-      if (this.config.getAuthToken) {
-        const token = await this.config.getAuthToken()
-        if (token) {
-          config.headers = {
-            ...config.headers,
-            Authorization: \`Bearer \${token}\`
-          }
-        }
-      }`;
-            case 'apiKey':
-                return `
-      // Inject API key if available
-      if (this.config.getApiKey) {
-        const apiKey = await this.config.getApiKey()
-        if (apiKey) {
-          if (this.config.apiKeyHeader) {
-            config.headers = {
-              ...config.headers,
-              [this.config.apiKeyHeader]: apiKey
-            }
-          } else {
-            config.params = { ...config.params, api_key: apiKey }
-          }
-        }
-      }`;
-            case 'basic':
-                return `
-      // Inject basic auth if available
-      if (this.config.getBasicAuth) {
-        const auth = await this.config.getBasicAuth()
-        if (auth) {
-          const encoded = btoa(\`\${auth.username}:\${auth.password}\`)
-          config.headers = {
-            ...config.headers,
-            Authorization: \`Basic \${encoded}\`
-          }
-        }
-      }`;
-            default:
-                return '';
-        }
-    }
-    generateFetchAuthInjection() {
-        switch (this.options.authType) {
-            case 'bearer':
-                return `
-      // Inject bearer token if available
-      if (this.config.getAuthToken) {
-        const token = await this.config.getAuthToken()
-        if (token) {
-          fetchOptions.headers = {
-            ...fetchOptions.headers,
-            Authorization: \`Bearer \${token}\`
-          }
-        }
-      }`;
-            case 'apiKey':
-                return `
-      // Inject API key if available
-      if (this.config.getApiKey) {
-        const apiKey = await this.config.getApiKey()
-        if (apiKey && this.config.apiKeyHeader) {
-          fetchOptions.headers = {
-            ...fetchOptions.headers,
-            [this.config.apiKeyHeader]: apiKey
-          }
-        }
-      }`;
-            default:
-                return '';
-        }
-    }
-    generateApiMethods(endpoints) {
-        const methods = [];
-        methods.push(this.generateFileHeader('API Methods'));
-        methods.push('');
-        methods.push('import { APIClient } from \'./client\'');
-        methods.push('import * as Types from \'./types\'');
-        methods.push('');
-        methods.push('export class APIService {');
-        methods.push('  constructor(private client: APIClient) {}');
-        methods.push('');
-        // Group endpoints by tags or path prefix
-        const groupedEndpoints = this.groupEndpoints(endpoints);
-        for (const [group, groupEndpoints] of Object.entries(groupedEndpoints)) {
-            methods.push(`  // ${group} methods`);
-            for (const endpoint of groupEndpoints) {
-                const method = this.generateEndpointMethod(endpoint);
-                methods.push(method);
-                methods.push('');
-            }
-        }
-        methods.push('}');
-        return methods.join('\n');
-    }
-    generateEndpointMethod(endpoint) {
-        const methodName = this.getMethodName(endpoint);
-        const pathWithParams = this.generatePathWithParams(endpoint);
-        const httpMethod = endpoint.method.toLowerCase();
-        const lines = [];
-        // Generate JSDoc
-        lines.push('  /**');
-        if (endpoint.summary) {
-            lines.push(`   * ${endpoint.summary}`);
-        }
-        if (endpoint.description) {
-            lines.push(`   * ${endpoint.description}`);
-        }
-        lines.push(`   * @param options Request options`);
-        lines.push('   */');
-        // Generate method signature
-        const hasPathParams = endpoint.parameters.some(p => p.in === 'path');
-        const hasQueryParams = endpoint.parameters.some(p => p.in === 'query');
-        const hasBody = endpoint.requestBody !== undefined;
-        let params = 'options: RequestOptions = {}';
-        if (hasPathParams) {
-            const pathParams = endpoint.parameters
-                .filter(p => p.in === 'path')
-                .map(p => `${p.name}: ${this.getParameterType(p)}`)
-                .join(', ');
-            params = `${pathParams}, ${params}`;
-        }
-        const responseType = this.getResponseType(endpoint);
-        lines.push(`  async ${methodName}(${params}): Promise<${responseType}> {`);
-        // Generate method body
-        const urlConstruction = hasPathParams ?
-            `const url = \`${pathWithParams}\`` :
-            `const url = '${endpoint.path}'`;
-        lines.push(`    ${urlConstruction}`);
-        if (hasQueryParams) {
-            lines.push('    const queryParams = {');
-            endpoint.parameters
-                .filter(p => p.in === 'query')
-                .forEach(p => {
-                lines.push(`      ${p.name}: options.${p.name},`);
-            });
-            lines.push('    }');
-            lines.push('    options.params = { ...queryParams, ...options.params }');
-        }
-        if (hasBody) {
-            lines.push(`    return this.client.${httpMethod}<${responseType}>(url, options.data, options)`);
-        }
-        else {
-            lines.push(`    return this.client.${httpMethod}<${responseType}>(url, options)`);
-        }
-        lines.push('  }');
-        return lines.join('\n');
-    }
-    generateClientTypes() {
-        const authTypes = this.generateAuthTypes();
-        return `/**
- * API Client Types
- *
- * Configuration and utility types for the generated API client
- */
-
-${this.options.clientType === 'axios' ? "import { AxiosRequestConfig, AxiosResponse } from 'axios'" : ''}
-
-export interface APIClientConfig {
-  baseUrl: string
-  timeout?: number
-  defaultHeaders?: Record<string, string>
-  retries?: number
-  ${this.options.includeAuth ? authTypes : ''}
-  onRequest?: (config: any) => any
-  onRequestError?: (error: any) => void
-  onResponse?: (response: any) => any
-  onResponseError?: (error: any) => Promise<any> | any
-  onError?: (error: APIError) => void
-}
-
-export interface RequestOptions {
-  params?: Record<string, any>
-  data?: any
-  headers?: Record<string, string>
-  config?: any
-  signal?: AbortSignal
-  [key: string]: any
-}
-
-export interface APIError {
-  message: string
-  status?: number
-  statusText?: string
-  data?: any
-  config: {
-    url?: string
-    method?: string
-    headers?: any
-  }
-}`;
-    }
-    generateAuthTypes() {
-        switch (this.options.authType) {
-            case 'bearer':
-                return 'getAuthToken?: () => Promise<string | null> | string | null';
-            case 'apiKey':
-                return `getApiKey?: () => Promise<string | null> | string | null
-  apiKeyHeader?: string`;
-            case 'basic':
-                return 'getBasicAuth?: () => Promise<{ username: string; password: string } | null> | { username: string; password: string } | null';
-            default:
-                return '';
-        }
-    }
-    generateConfiguration() {
-        return `/**
- * API Client Configuration
- *
- * Default configuration and factory functions
- */
-
-import { APIClient } from './client'
-import { APIService } from './methods'
-import { APIClientConfig } from './types'
-
-export function createAPIClient(config: APIClientConfig): APIService {
-  const client = new APIClient(config)
-  return new APIService(client)
-}
-
-export const defaultConfig: Partial<APIClientConfig> = {
-  timeout: ${this.options.timeout},
-  retries: ${this.options.retries},
-  defaultHeaders: {
-    'Content-Type': 'application/json'
-  }
-}`;
-    }
-    generateIndexFile() {
-        return `/**
- * Generated API Client
- *
- * Auto-generated from OpenAPI specification
- */
-
-export * from './client'
-export * from './methods'
-export * from './types'
-export * from './config'
-export { createAPIClient, defaultConfig } from './config'`;
-    }
-    generateFileHeader(title) {
-        return `/**
- * ${title}
- *
- * Auto-generated from OpenAPI specification
- * Do not edit manually
- */`;
-    }
-    getMethodName(endpoint) {
-        // Use semantic naming instead of raw operationId
-        return this.generateSemanticMethodName(endpoint);
-    }
-    generateSemanticMethodName(endpoint) {
-        // Extract resource from path
-        const pathSegments = endpoint.path.split('/').filter(s => s && !s.startsWith('{') && !['api', 'v1', 'v2'].includes(s));
-        const urlSegments = endpoint.path.split('/');
-        const hasPathParam = endpoint.path.includes('{');
-        const lastSegment = pathSegments[pathSegments.length - 1]?.replace(/-/g, '_') || 'resource';
-        const prevSegment = pathSegments[pathSegments.length - 2]?.replace(/-/g, '_');
-
-        // Auth endpoints - use action name directly
-        if (AUTH_ACTIONS.includes(lastSegment.toLowerCase())) {
-            return this.camelCase(lastSegment);
-        }
-
-        // Health/status singletons
-        if (HEALTH_ENDPOINTS.includes(lastSegment.toLowerCase())) {
-            return this.camelCase(lastSegment);
-        }
-
-        // User profile singletons
-        if (USER_PROFILE_ENDPOINTS.includes(lastSegment.toLowerCase())) {
-            return this.camelCase(`get_current_user`);
-        }
-
-        // Metadata endpoints - include parent resource to avoid collision
-        if (lastSegment.toLowerCase() === 'metadata' && prevSegment) {
-            return hasPathParam
-                ? this.camelCase(`get_${singularize(prevSegment)}_metadata`)
-                : this.camelCase(`get_${prevSegment}_metadata`);
-        }
-
-        // Collection actions (e.g., /activities/search)
-        if (COLLECTION_ACTIONS.includes(lastSegment.toLowerCase()) && prevSegment) {
-            return this.camelCase(`${lastSegment}_${prevSegment}`);
-        }
-
-        // Determine resource name - for nested paths, include context
-        let resource = lastSegment;
-        if (pathSegments.length > 2 && hasPathParam) {
-            // e.g., /accounts/{id}/stages/allowed → get_account_allowed_stages
-            const parentResource = pathSegments.find((s, i) => {
-                const nextSeg = urlSegments[urlSegments.findIndex(u => u === s) + 1];
-                return nextSeg?.startsWith('{');
-            });
-            if (parentResource && parentResource !== lastSegment) {
-                resource = `${singularize(parentResource)}_${lastSegment}`;
-            }
-        }
-
-        // Generate name based on HTTP method
-        switch (endpoint.method) {
-            case 'get':
-                return hasPathParam
-                    ? this.camelCase(`get_${singularize(resource)}`)
-                    : this.camelCase(`list_${resource}`);
-            case 'post':
-                // Check for custom actions like /accounts/{id}/stage
-                const lastUrl = urlSegments[urlSegments.length - 1];
-                const prevUrl = urlSegments[urlSegments.length - 2];
-                if (!lastUrl.startsWith('{') && prevUrl?.startsWith('{')) {
-                    return this.camelCase(`${lastUrl}_${singularize(prevSegment || resource)}`);
-                }
-                return this.camelCase(`create_${singularize(resource)}`);
-            case 'put':
-            case 'patch':
-                return this.camelCase(`update_${singularize(resource)}`);
-            case 'delete':
-                return this.camelCase(`delete_${singularize(resource)}`);
-            default:
-                return this.camelCase(`${endpoint.method}_${resource}`);
-        }
-    }
-    generatePathWithParams(endpoint) {
-        return endpoint.path.replace(/{([^}]+)}/g, '${$1}');
-    }
-    getParameterType(param) {
-        switch (param.schema.type) {
-            case 'string': return 'string';
-            case 'number':
-            case 'integer': return 'number';
-            case 'boolean': return 'boolean';
-            default: return 'any';
-        }
-    }
-    getResponseType(endpoint) {
-        // Find success response (2xx)
-        const successResponse = endpoint.responses.find(r => r.statusCode.startsWith('2') || r.statusCode === 'default');
-        if (!successResponse?.content) {
-            return 'void';
-        }
-        const jsonContent = successResponse.content['application/json'];
-        if (!jsonContent) {
-            return 'any';
-        }
-        // This would need to be enhanced to generate proper type references
-        return 'any';
-    }
-    groupEndpoints(endpoints) {
-        const groups = {};
-        for (const endpoint of endpoints) {
-            const group = endpoint.tags?.[0] || 'default';
-            if (!groups[group]) {
-                groups[group] = [];
-            }
-            groups[group].push(endpoint);
-        }
-        return groups;
-    }
-    camelCase(str) {
-        return str.replace(/[-_](.)/g, (_, char) => char.toUpperCase())
-            .replace(/^./, char => char.toLowerCase());
-    }
-    capitalize(str) {
-        return str.charAt(0).toUpperCase() + str.slice(1);
-    }
-}
-// Factory function
-export function generateAPIClient(parsedAPI, options) {
-    const generator = new APIClientGenerator(options);
-    return generator.generate(parsedAPI);
-}