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

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

@@ -1,329 +0,0 @@
-/**
- * TypeScript Type Generator
- *
- * Creates TypeScript interfaces and types from parsed OpenAPI schemas
- * with proper naming conventions and structure.
- *
- * Part of FRO-10: TypeScript Type Generator
- */
-export class TypeScriptGenerator {
-    options;
-    generatedTypes = new Set();
-    refMap = new Map();
-    constructor(options = {}) {
-        this.options = {
-            prefix: options.prefix || '',
-            suffix: options.suffix || '',
-            enumStyle: options.enumStyle || 'union',
-            nullableStyle: options.nullableStyle || 'undefined',
-            includeJSDoc: options.includeJSDoc !== false,
-            includeExamples: options.includeExamples !== false
-        };
-    }
-    generate(parsedAPI) {
-        // Reset state
-        this.generatedTypes.clear();
-        this.refMap.clear();
-        // Build reference map first
-        this.buildRefMap(parsedAPI);
-        return {
-            schemas: this.generateSchemas(parsedAPI.schemas),
-            endpoints: this.generateEndpointTypes(parsedAPI.endpoints),
-            parameters: this.generateParameterTypes(parsedAPI.endpoints),
-            responses: this.generateResponseTypes(parsedAPI.endpoints),
-            index: this.generateIndexFile()
-        };
-    }
-    buildRefMap(parsedAPI) {
-        // Build map of ref -> TypeScript type name
-        parsedAPI.schemas.forEach(schema => {
-            if (schema.ref) {
-                const typeName = this.extractTypeNameFromRef(schema.ref);
-                this.refMap.set(schema.ref, typeName);
-            }
-        });
-    }
-    generateSchemas(schemas) {
-        const types = [];
-        // Add file header
-        types.push(this.generateFileHeader('Schema Types'));
-        for (const schema of schemas) {
-            if (!schema.ref)
-                continue;
-            const typeName = this.refMap.get(schema.ref);
-            if (!typeName || this.generatedTypes.has(typeName))
-                continue;
-            const typeDefinition = this.generateSchemaType(schema, typeName);
-            types.push(typeDefinition);
-            this.generatedTypes.add(typeName);
-        }
-        return types.join('\n\n');
-    }
-    generateSchemaType(schema, typeName) {
-        const lines = [];
-        // Add JSDoc comment
-        if (this.options.includeJSDoc && schema.description) {
-            lines.push(`/**`);
-            lines.push(` * ${schema.description}`);
-            if (this.options.includeExamples && schema.example) {
-                lines.push(` * @example ${JSON.stringify(schema.example)}`);
-            }
-            lines.push(` */`);
-        }
-        // Generate the type
-        const typeContent = this.generateTypeContent(schema);
-        lines.push(`export interface ${typeName} ${typeContent}`);
-        return lines.join('\n');
-    }
-    generateTypeContent(schema) {
-        switch (schema.type) {
-            case 'object':
-                return this.generateObjectType(schema);
-            case 'array':
-                return `${this.generateTypeContent(schema.items)}[]`;
-            case 'string':
-                if (schema.enum) {
-                    return this.generateEnumType(schema.enum);
-                }
-                return this.addNullable('string', schema.nullable);
-            case 'number':
-            case 'integer':
-                return this.addNullable('number', schema.nullable);
-            case 'boolean':
-                return this.addNullable('boolean', schema.nullable);
-            case 'null':
-                return 'null';
-            case 'any':
-                if (schema.ref) {
-                    const refType = this.refMap.get(schema.ref);
-                    return refType || 'unknown';
-                }
-                return 'unknown';
-            default:
-                return 'unknown';
-        }
-    }
-    generateObjectType(schema) {
-        if (!schema.properties) {
-            return '{ [key: string]: unknown }';
-        }
-        const properties = [];
-        for (const [propName, propSchema] of Object.entries(schema.properties)) {
-            const isRequired = schema.required?.includes(propName) || false;
-            const isOptional = !isRequired ? '?' : '';
-            const propType = this.generateTypeContent(propSchema);
-            // Add JSDoc for property if available
-            let propDoc = '';
-            if (this.options.includeJSDoc && propSchema.description) {
-                propDoc = `  /** ${propSchema.description} */\n  `;
-            }
-            properties.push(`${propDoc}${propName}${isOptional}: ${propType}`);
-        }
-        return `{\n  ${properties.join('\n  ')}\n}`;
-    }
-    generateEnumType(enumValues) {
-        if (this.options.enumStyle === 'enum') {
-            // Generate enum declaration (would need to be handled separately)
-            return enumValues.map(val => `'${val}'`).join(' | ');
-        }
-        else {
-            return enumValues.map(val => `'${val}'`).join(' | ');
-        }
-    }
-    addNullable(type, nullable) {
-        if (!nullable)
-            return type;
-        switch (this.options.nullableStyle) {
-            case 'null':
-                return `${type} | null`;
-            case 'both':
-                return `${type} | null | undefined`;
-            case 'undefined':
-            default:
-                return `${type} | undefined`;
-        }
-    }
-    generateEndpointTypes(endpoints) {
-        const types = [];
-        types.push(this.generateFileHeader('Endpoint Types'));
-        // Group endpoints by operation ID or path+method
-        const endpointTypes = new Set();
-        for (const endpoint of endpoints) {
-            const operationName = this.getOperationName(endpoint);
-            if (endpointTypes.has(operationName))
-                continue;
-            endpointTypes.add(operationName);
-            // Generate request type
-            const requestType = this.generateRequestType(endpoint, operationName);
-            if (requestType) {
-                types.push(requestType);
-            }
-            // Generate response type
-            const responseType = this.generateResponseType(endpoint, operationName);
-            if (responseType) {
-                types.push(responseType);
-            }
-        }
-        return types.join('\n\n');
-    }
-    generateRequestType(endpoint, operationName) {
-        const hasParams = endpoint.parameters.length > 0;
-        const hasBody = endpoint.requestBody !== undefined;
-        if (!hasParams && !hasBody)
-            return null;
-        const lines = [];
-        if (this.options.includeJSDoc) {
-            lines.push(`/**`);
-            lines.push(` * Request type for ${endpoint.method.toUpperCase()} ${endpoint.path}`);
-            if (endpoint.summary) {
-                lines.push(` * ${endpoint.summary}`);
-            }
-            lines.push(` */`);
-        }
-        const properties = [];
-        // Add parameters
-        if (hasParams) {
-            const paramsByType = this.groupParametersByType(endpoint.parameters);
-            for (const [paramType, params] of Object.entries(paramsByType)) {
-                if (params.length === 0)
-                    continue;
-                const paramProps = params.map(param => {
-                    const optional = param.required ? '' : '?';
-                    const type = this.generateTypeContent(param.schema);
-                    return `    ${param.name}${optional}: ${type}`;
-                });
-                properties.push(`  ${paramType}: {\n${paramProps.join('\n')}\n  }`);
-            }
-        }
-        // Add request body
-        if (hasBody && endpoint.requestBody) {
-            const bodyType = this.generateRequestBodyType(endpoint.requestBody);
-            const optional = endpoint.requestBody.required ? '' : '?';
-            properties.push(`  body${optional}: ${bodyType}`);
-        }
-        const typeName = `${this.formatTypeName(operationName)}Request`;
-        lines.push(`export interface ${typeName} {`);
-        lines.push(properties.join('\n'));
-        lines.push(`}`);
-        return lines.join('\n');
-    }
-    generateResponseType(endpoint, operationName) {
-        if (endpoint.responses.length === 0)
-            return null;
-        const lines = [];
-        if (this.options.includeJSDoc) {
-            lines.push(`/**`);
-            lines.push(` * Response type for ${endpoint.method.toUpperCase()} ${endpoint.path}`);
-            if (endpoint.summary) {
-                lines.push(` * ${endpoint.summary}`);
-            }
-            lines.push(` */`);
-        }
-        // Generate union type for all possible responses
-        const responseTypes = [];
-        for (const response of endpoint.responses) {
-            if (response.content) {
-                for (const [mediaType, content] of Object.entries(response.content)) {
-                    if (mediaType.includes('json')) {
-                        const type = this.generateTypeContent(content.schema);
-                        responseTypes.push(`{ status: ${response.statusCode}; data: ${type} }`);
-                    }
-                }
-            }
-            else {
-                responseTypes.push(`{ status: ${response.statusCode}; data: void }`);
-            }
-        }
-        const typeName = `${this.formatTypeName(operationName)}Response`;
-        const unionType = responseTypes.length > 1 ? responseTypes.join(' | ') : responseTypes[0] || 'void';
-        lines.push(`export type ${typeName} = ${unionType}`);
-        return lines.join('\n');
-    }
-    generateRequestBodyType(requestBody) {
-        // Find JSON content type
-        const jsonContent = requestBody.content['application/json'] ||
-            requestBody.content['application/vnd.api+json'] ||
-            Object.values(requestBody.content)[0];
-        if (!jsonContent)
-            return 'unknown';
-        return this.generateTypeContent(jsonContent.schema);
-    }
-    generateParameterTypes(_endpoints) {
-        const types = [];
-        types.push(this.generateFileHeader('Parameter Types'));
-        // This could be expanded to generate specific parameter types
-        // For now, we'll keep it simple
-        return types.join('\n\n');
-    }
-    generateResponseTypes(_endpoints) {
-        const types = [];
-        types.push(this.generateFileHeader('Response Types'));
-        // Additional response type utilities could go here
-        return types.join('\n\n');
-    }
-    generateIndexFile() {
-        const lines = [];
-        lines.push(this.generateFileHeader('Generated API Types'));
-        lines.push('');
-        lines.push('// Schema exports');
-        lines.push('export * from \'./schemas\'');
-        lines.push('');
-        lines.push('// Endpoint exports');
-        lines.push('export * from \'./endpoints\'');
-        lines.push('');
-        lines.push('// Parameter exports');
-        lines.push('export * from \'./parameters\'');
-        lines.push('');
-        lines.push('// Response exports');
-        lines.push('export * from \'./responses\'');
-        return lines.join('\n');
-    }
-    generateFileHeader(title) {
-        return `/**
- * ${title}
- * 
- * Auto-generated from OpenAPI specification
- * Do not edit manually - regenerate using the OpenAPI type generator
- */`;
-    }
-    getOperationName(endpoint) {
-        if (endpoint.operationId) {
-            return endpoint.operationId;
-        }
-        // Generate from path and method
-        const pathParts = endpoint.path
-            .split('/')
-            .filter(part => part && !part.startsWith('{'))
-            .map(part => this.capitalize(part));
-        return `${endpoint.method}${pathParts.join('')}`;
-    }
-    formatTypeName(name) {
-        const formatted = this.capitalize(name);
-        return `${this.options.prefix}${formatted}${this.options.suffix}`;
-    }
-    extractTypeNameFromRef(ref) {
-        const parts = ref.split('/');
-        const name = parts[parts.length - 1];
-        return this.formatTypeName(name);
-    }
-    groupParametersByType(parameters) {
-        const grouped = {
-            path: [],
-            query: [],
-            header: [],
-            cookie: []
-        };
-        for (const param of parameters) {
-            grouped[param.in].push(param);
-        }
-        return grouped;
-    }
-    capitalize(str) {
-        return str.charAt(0).toUpperCase() + str.slice(1);
-    }
-}
-// Factory function for easy usage
-export function generateTypes(parsedAPI, options) {
-    const generator = new TypeScriptGenerator(options);
-    return generator.generate(parsedAPI);
-}

package/dist/codegen/openapi/bulk-types.d.ts

@@ -1,142 +0,0 @@
-/**
- * Bulk Operations Types
- *
- * Standard types for bulk operations in generated hooks
- * Part of FRO-35: Bulk Operations Hook Generation
- */
-/**
- * Standard bulk operation request format
- */
-export interface BulkOperationRequest<T = unknown> {
-    /** Array of IDs to operate on */
-    ids: Array<string | number>;
-    /** Optional additional data for the operation */
-    data?: T;
-    /** Optional operation-specific options */
-    options?: BulkOperationOptions;
-}
-/**
- * Options for bulk operations
- */
-export interface BulkOperationOptions {
-    /** Continue processing if some items fail */
-    continueOnError?: boolean;
-    /** Batch size for processing */
-    batchSize?: number;
-    /** Progress callback */
-    onProgress?: (progress: BulkOperationProgress) => void;
-}
-/**
- * Progress tracking for bulk operations
- */
-export interface BulkOperationProgress {
-    /** Total number of items to process */
-    total: number;
-    /** Number of items processed so far */
-    processed: number;
-    /** Number of successful operations */
-    succeeded: number;
-    /** Number of failed operations */
-    failed: number;
-    /** Percentage complete (0-100) */
-    percentage: number;
-    /** Current status */
-    status: "pending" | "processing" | "completed" | "failed";
-}
-/**
- * Standard bulk operation response format
- */
-export interface BulkOperationResponse<T = unknown> {
-    /** Overall operation success */
-    success: boolean;
-    /** Results for successful operations */
-    succeeded: BulkOperationResult<T>[];
-    /** Results for failed operations */
-    failed: BulkOperationError[];
-    /** Summary statistics */
-    summary: BulkOperationSummary;
-}
-/**
- * Individual result for a successful bulk operation
- */
-export interface BulkOperationResult<T = unknown> {
-    /** ID of the processed item */
-    id: string | number;
-    /** Result data */
-    data?: T;
-    /** Operation-specific message */
-    message?: string;
-}
-/**
- * Individual error for a failed bulk operation
- */
-export interface BulkOperationError {
-    /** ID of the failed item */
-    id: string | number;
-    /** Error code */
-    code?: string;
-    /** Error message */
-    message: string;
-    /** Detailed error information */
-    details?: unknown;
-    /** Whether this error is retryable */
-    retryable?: boolean;
-}
-/**
- * Summary statistics for bulk operations
- */
-export interface BulkOperationSummary {
-    /** Total items requested */
-    total: number;
-    /** Successfully processed items */
-    succeeded: number;
-    /** Failed items */
-    failed: number;
-    /** Processing duration in ms */
-    duration?: number;
-    /** Operation timestamp */
-    timestamp: string;
-}
-/**
- * Retry configuration for bulk operations
- */
-export interface BulkRetryConfig {
-    /** Maximum number of retry attempts */
-    maxAttempts?: number;
-    /** Initial delay between retries (ms) */
-    initialDelay?: number;
-    /** Maximum delay between retries (ms) */
-    maxDelay?: number;
-    /** Backoff multiplier */
-    backoffMultiplier?: number;
-    /** Which errors should trigger a retry */
-    retryOn?: (error: BulkOperationError) => boolean;
-}
-/**
- * Hook options specific to bulk operations
- */
-export interface BulkMutationOptions<TData = unknown, TVariables = unknown> {
-    /** Retry configuration */
-    retry?: BulkRetryConfig;
-    /** Progress tracking */
-    onProgress?: (progress: BulkOperationProgress) => void;
-    /** Callback for partial success */
-    onPartialSuccess?: (response: BulkOperationResponse<TData>) => void;
-    /** Transform function for request */
-    transformRequest?: (request: BulkOperationRequest<TVariables>) => unknown;
-    /** Transform function for response */
-    transformResponse?: (response: unknown) => BulkOperationResponse<TData>;
-}
-/**
- * Type guard to check if an endpoint handles bulk operations
- */
-export declare function isBulkOperation(path: string, _method: string, requestBody?: unknown): boolean;
-/**
- * Detect bulk operation type from endpoint
- */
-export declare function detectBulkOperationType(path: string, method: string): "create" | "update" | "delete" | "mixed" | null;
-/**
- * Generate a descriptive bulk operation name
- */
-export declare function generateBulkOperationName(resource: string, operationType: string): string;
-//# sourceMappingURL=bulk-types.d.ts.map

package/dist/codegen/openapi/bulk-types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bulk-types.d.ts","sourceRoot":"","sources":["../../../src/codegen/openapi/bulk-types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;GAEG;AACH,MAAM,WAAW,oBAAoB,CAAC,CAAC,GAAG,OAAO;IAC/C,iCAAiC;IACjC,GAAG,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC;IAC5B,iDAAiD;IACjD,IAAI,CAAC,EAAE,CAAC,CAAC;IACT,0CAA0C;IAC1C,OAAO,CAAC,EAAE,oBAAoB,CAAC;CAChC;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,6CAA6C;IAC7C,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,gCAAgC;IAChC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,wBAAwB;IACxB,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,qBAAqB,KAAK,IAAI,CAAC;CACxD;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,uCAAuC;IACvC,KAAK,EAAE,MAAM,CAAC;IACd,uCAAuC;IACvC,SAAS,EAAE,MAAM,CAAC;IAClB,sCAAsC;IACtC,SAAS,EAAE,MAAM,CAAC;IAClB,kCAAkC;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,kCAAkC;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,qBAAqB;IACrB,MAAM,EAAE,SAAS,GAAG,YAAY,GAAG,WAAW,GAAG,QAAQ,CAAC;CAC3D;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB,CAAC,CAAC,GAAG,OAAO;IAChD,gCAAgC;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,wCAAwC;IACxC,SAAS,EAAE,mBAAmB,CAAC,CAAC,CAAC,EAAE,CAAC;IACpC,oCAAoC;IACpC,MAAM,EAAE,kBAAkB,EAAE,CAAC;IAC7B,yBAAyB;IACzB,OAAO,EAAE,oBAAoB,CAAC;CAC/B;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB,CAAC,CAAC,GAAG,OAAO;IAC9C,+BAA+B;IAC/B,EAAE,EAAE,MAAM,GAAG,MAAM,CAAC;IACpB,kBAAkB;IAClB,IAAI,CAAC,EAAE,CAAC,CAAC;IACT,iCAAiC;IACjC,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,4BAA4B;IAC5B,EAAE,EAAE,MAAM,GAAG,MAAM,CAAC;IACpB,iBAAiB;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,oBAAoB;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,iCAAiC;IACjC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,sCAAsC;IACtC,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,4BAA4B;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,mCAAmC;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,mBAAmB;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,gCAAgC;IAChC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,0BAA0B;IAC1B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,uCAAuC;IACvC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,yCAAyC;IACzC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,yCAAyC;IACzC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,yBAAyB;IACzB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,0CAA0C;IAC1C,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,kBAAkB,KAAK,OAAO,CAAC;CAClD;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB,CAAC,KAAK,GAAG,OAAO,EAAE,UAAU,GAAG,OAAO;IACxE,0BAA0B;IAC1B,KAAK,CAAC,EAAE,eAAe,CAAC;IACxB,wBAAwB;IACxB,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,qBAAqB,KAAK,IAAI,CAAC;IACvD,mCAAmC;IACnC,gBAAgB,CAAC,EAAE,CAAC,QAAQ,EAAE,qBAAqB,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC;IACpE,qCAAqC;IACrC,gBAAgB,CAAC,EAAE,CAAC,OAAO,EAAE,oBAAoB,CAAC,UAAU,CAAC,KAAK,OAAO,CAAC;IAC1E,sCAAsC;IACtC,iBAAiB,CAAC,EAAE,CAAC,QAAQ,EAAE,OAAO,KAAK,qBAAqB,CAAC,KAAK,CAAC,CAAC;CACzE;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,WAAW,CAAC,EAAE,OAAO,GACpB,OAAO,CAuCT;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,GACb,QAAQ,GAAG,QAAQ,GAAG,QAAQ,GAAG,OAAO,GAAG,IAAI,CAyBjD;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,MAAM,GACpB,MAAM,CAqBR"}