@pattern-stack/frontend-patterns 0.2.0-alpha.0 → 0.2.0-alpha.11

package/cli/src/codegen/openapi/parser.js

@@ -1,274 +0,0 @@
-/**
- * OpenAPI Parser Implementation
- *
- * Core parser that reads OpenAPI 3.0 specifications and converts them
- * into an intermediate representation for code generation.
- *
- * Part of FRO-11: OpenAPI Parser Implementation
- */
-import { promises as fs } from 'fs';
-import { resolve } from 'path';
-// Main parser class
-export class OpenAPIParser {
-    spec;
-    refs = new Map();
-    constructor(spec) {
-        this.spec = spec;
-        this.buildRefsMap();
-    }
-    /**
-     * Parse the OpenAPI specification into our intermediate representation
-     */
-    parse() {
-        return {
-            info: this.parseInfo(),
-            servers: this.parseServers(),
-            endpoints: this.parseEndpoints(),
-            schemas: this.parseSchemas(),
-            security: this.parseSecurity()
-        };
-    }
-    parseInfo() {
-        return {
-            title: this.spec.info.title,
-            version: this.spec.info.version,
-            description: this.spec.info.description
-        };
-    }
-    parseServers() {
-        if (!this.spec.servers)
-            return [];
-        return this.spec.servers.map(server => ({
-            url: server.url,
-            description: server.description,
-            variables: server.variables ?
-                Object.fromEntries(Object.entries(server.variables).map(([key, variable]) => [
-                    key,
-                    variable.default || ''
-                ])) : undefined
-        }));
-    }
-    parseEndpoints() {
-        const endpoints = [];
-        for (const [path, pathItem] of Object.entries(this.spec.paths || {})) {
-            if (!pathItem)
-                continue;
-            const methods = ['get', 'post', 'put', 'patch', 'delete', 'head', 'options'];
-            for (const method of methods) {
-                const operation = pathItem[method];
-                if (!operation)
-                    continue;
-                endpoints.push({
-                    path,
-                    method,
-                    operationId: operation.operationId,
-                    summary: operation.summary,
-                    description: operation.description,
-                    tags: operation.tags,
-                    parameters: this.parseParameters(operation.parameters),
-                    requestBody: operation.requestBody ? this.parseRequestBody(operation.requestBody) : undefined,
-                    responses: this.parseResponses(operation.responses),
-                    security: operation.security ? this.parseOperationSecurity(operation.security) : undefined
-                });
-            }
-        }
-        return endpoints;
-    }
-    parseParameters(parameters) {
-        if (!parameters)
-            return [];
-        return parameters.map(param => {
-            const resolved = this.resolveRef(param);
-            return {
-                name: resolved.name,
-                in: resolved.in,
-                required: resolved.required || false,
-                schema: this.parseSchema(resolved.schema),
-                description: resolved.description
-            };
-        });
-    }
-    parseRequestBody(requestBody) {
-        const resolved = this.resolveRef(requestBody);
-        return {
-            required: resolved.required || false,
-            description: resolved.description,
-            content: Object.fromEntries(Object.entries(resolved.content || {}).map(([mediaType, mediaTypeObj]) => [
-                mediaType,
-                { schema: this.parseSchema(mediaTypeObj.schema) }
-            ]))
-        };
-    }
-    parseResponses(responses) {
-        return Object.entries(responses).map(([statusCode, response]) => {
-            const resolved = this.resolveRef(response);
-            return {
-                statusCode,
-                description: resolved.description,
-                content: resolved.content ?
-                    Object.fromEntries(Object.entries(resolved.content).map(([mediaType, mediaTypeObj]) => [
-                        mediaType,
-                        { schema: this.parseSchema(mediaTypeObj.schema) }
-                    ])) : undefined,
-                headers: resolved.headers ?
-                    Object.fromEntries(Object.entries(resolved.headers).map(([headerName, header]) => [
-                        headerName,
-                        this.parseSchema(this.resolveRef(header).schema)
-                    ])) : undefined
-            };
-        });
-    }
-    parseSchema(schema) {
-        if (!schema) {
-            return { type: 'any' };
-        }
-        // Handle $ref
-        if ('$ref' in schema) {
-            return {
-                type: 'any', // Will be resolved later
-                ref: schema.$ref,
-                originalRef: schema.$ref
-            };
-        }
-        const resolved = schema;
-        // Handle array type
-        if (resolved.type === 'array') {
-            return {
-                type: 'array',
-                items: this.parseSchema(resolved.items),
-                description: resolved.description,
-                nullable: resolved.nullable
-            };
-        }
-        // Handle object type
-        if (resolved.type === 'object' || resolved.properties) {
-            return {
-                type: 'object',
-                properties: resolved.properties ?
-                    Object.fromEntries(Object.entries(resolved.properties).map(([propName, propSchema]) => [
-                        propName,
-                        this.parseSchema(propSchema)
-                    ])) : undefined,
-                required: resolved.required,
-                description: resolved.description,
-                nullable: resolved.nullable
-            };
-        }
-        // Handle primitive types
-        const type = this.mapOpenAPIType(resolved.type);
-        return {
-            type,
-            format: resolved.format,
-            enum: resolved.enum,
-            description: resolved.description,
-            example: resolved.example,
-            nullable: resolved.nullable
-        };
-    }
-    parseSchemas() {
-        if (!this.spec.components?.schemas)
-            return [];
-        return Object.entries(this.spec.components.schemas).map(([name, schema]) => ({
-            ...this.parseSchema(schema),
-            ref: `#/components/schemas/${name}`
-        }));
-    }
-    parseSecurity() {
-        if (!this.spec.components?.securitySchemes)
-            return [];
-        return Object.entries(this.spec.components.securitySchemes).map(([_name, scheme]) => {
-            const resolved = this.resolveRef(scheme);
-            return {
-                type: resolved.type,
-                scheme: 'scheme' in resolved ? resolved.scheme : undefined,
-                bearerFormat: 'bearerFormat' in resolved ? resolved.bearerFormat : undefined,
-                in: 'in' in resolved ? resolved.in : undefined,
-                name: 'name' in resolved ? resolved.name : undefined,
-                flows: 'flows' in resolved ? resolved.flows : undefined,
-                openIdConnectUrl: 'openIdConnectUrl' in resolved ? resolved.openIdConnectUrl : undefined
-            };
-        });
-    }
-    parseOperationSecurity(_security) {
-        // Simplified - would need to match with security schemes
-        return [];
-    }
-    mapOpenAPIType(type) {
-        switch (type) {
-            case 'string': return 'string';
-            case 'number': return 'number';
-            case 'integer': return 'integer';
-            case 'boolean': return 'boolean';
-            case 'array': return 'array';
-            case 'object': return 'object';
-            case 'null': return 'null';
-            default: return 'any';
-        }
-    }
-    buildRefsMap() {
-        // Build a map of all $ref targets for quick resolution
-        this.traverseAndMapRefs(this.spec, '');
-    }
-    traverseAndMapRefs(obj, currentPath) {
-        if (typeof obj !== 'object' || obj === null)
-            return;
-        for (const [key, value] of Object.entries(obj)) {
-            const path = currentPath ? `${currentPath}/${key}` : key;
-            if (key === '$ref' && typeof value === 'string') {
-                // Don't store the ref itself, we'll resolve it when needed
-                continue;
-            }
-            if (typeof value === 'object') {
-                // Store objects that could be referenced
-                if (currentPath.includes('/components/')) {
-                    this.refs.set(`#/${path}`, value);
-                }
-                this.traverseAndMapRefs(value, path);
-            }
-        }
-    }
-    resolveRef(item) {
-        if (typeof item === 'object' && item !== null && '$ref' in item) {
-            const ref = item.$ref;
-            const resolved = this.refs.get(ref);
-            if (!resolved) {
-                throw new Error(`Could not resolve reference: ${ref}`);
-            }
-            return resolved;
-        }
-        return item;
-    }
-}
-// Factory function for easy usage
-export async function parseOpenAPI(spec) {
-    const parser = new OpenAPIParser(spec);
-    return parser.parse();
-}
-// Utility function to load OpenAPI from URL or file
-export async function loadOpenAPISpec(source) {
-    if (source.startsWith('http://') || source.startsWith('https://')) {
-        // Load from URL
-        const response = await fetch(source);
-        if (!response.ok) {
-            throw new Error(`Failed to load OpenAPI spec from ${source}: ${response.statusText}`);
-        }
-        return response.json();
-    }
-    else {
-        // Try to parse as JSON string first
-        try {
-            return JSON.parse(source);
-        }
-        catch {
-            // If JSON parse fails, try to read as file
-            try {
-                const absolutePath = resolve(source);
-                const content = await fs.readFile(absolutePath, 'utf8');
-                return JSON.parse(content);
-            }
-            catch (fileError) {
-                throw new Error(`Failed to load OpenAPI spec: Not a valid URL, JSON string, or file path. ${fileError}`);
-            }
-        }
-    }
-}

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);
-}