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

package/cli/src/codegen/openapi/naming-constants.js

@@ -1,98 +0,0 @@
-/**
- * Naming Constants
- *
- * Shared constants for magic strings used across hook and client generators.
- * These constants help identify special endpoints that get unique naming treatment.
- */
-
-/**
- * Authentication action endpoints
- * These endpoints are named directly without CRUD prefixes (e.g., 'login' not 'createLogin')
- */
-export const AUTH_ACTIONS = [
-  'login',
-  'logout',
-  'register',
-  'signup',
-  'signin',
-  'refresh'
-];
-
-/**
- * Health/status check endpoints
- * These are singleton endpoints that return system status
- */
-export const HEALTH_ENDPOINTS = [
-  'health',
-  'ready',
-  'status',
-  'info',
-  'version'
-];
-
-/**
- * User profile endpoints
- * These endpoints reference the current/authenticated user
- */
-export const USER_PROFILE_ENDPOINTS = [
-  'me',
-  'self',
-  'profile',
-  'current'
-];
-
-/**
- * Singleton resources
- * Resources that return a single item, not a collection
- * Includes all auth, health, and user profile endpoints plus common singleton patterns
- */
-export const SINGLETON_RESOURCES = [
-  'me',
-  'self',
-  'current',
-  'profile',
-  'health',
-  'ready',
-  'status',
-  'info',
-  'version',
-  'metadata',
-  'config',
-  'settings',
-  'preferences',
-  'summary',
-  'stats',
-  'statistics',
-  'dashboard',
-  'schema',
-  'spec',
-  'openapi'
-];
-
-/**
- * Collection action verbs
- * Actions that operate on collections (e.g., /activities/search)
- */
-export const COLLECTION_ACTIONS = [
-  'search',
-  'export',
-  'import',
-  'bulk',
-  'batch',
-  'count',
-  'stats',
-  'validate'
-];
-
-/**
- * Special actions - combination of auth, health, and user profile endpoints
- * These endpoints get special naming treatment and keep their action verb
- */
-export const SPECIAL_ACTIONS = [
-  ...AUTH_ACTIONS,
-  ...HEALTH_ENDPOINTS,
-  ...USER_PROFILE_ENDPOINTS,
-  'check',
-  'verify',
-  'validate'
-];

package/cli/src/codegen/openapi/naming-utils.js

@@ -1,149 +0,0 @@
-/**
- * Shared naming utilities for OpenAPI code generation
- * Handles singular/plural conversions with proper edge case handling
- */
-
-/**
- * Map of irregular plural forms
- */
-export const IRREGULAR_PLURALS = {
-    person: 'people',
-    child: 'children',
-    data: 'data',         // already plural
-    media: 'media',       // already plural
-    metadata: 'metadata', // already plural
-    people: 'people',     // already plural
-    children: 'children', // already plural
-};
-
-/**
- * Map of irregular singular forms (reverse lookup)
- */
-const IRREGULAR_SINGULARS = {
-    people: 'person',
-    children: 'child',
-    data: 'data',         // already singular
-    media: 'media',       // already singular
-    metadata: 'metadata', // already singular
-    person: 'person',     // already singular
-    child: 'child',       // already singular
-};
-
-/**
- * Words that naturally end in 's' but are singular
- */
-const SINGULAR_EXCEPTIONS = [
-    'status',
-    'class',
-    'address',
-    'access',
-    'success',
-    'process',
-    'bus',
-    'focus',
-    'virus',
-];
-
-/**
- * Check if a word is already plural
- * @param {string} word - The word to check
- * @returns {boolean} - True if the word is plural
- */
-export function isPlural(word) {
-    // Check irregular plurals first
-    if (IRREGULAR_PLURALS[word.toLowerCase()]) {
-        return IRREGULAR_PLURALS[word.toLowerCase()] === word.toLowerCase();
-    }
-
-    // Check singular exceptions - these end in 's' but are not plural
-    if (SINGULAR_EXCEPTIONS.includes(word.toLowerCase())) {
-        return false;
-    }
-
-    // Check common plural endings
-    if (word.endsWith('ies') || word.endsWith('es') || word.endsWith('s')) {
-        return true;
-    }
-
-    return false;
-}
-
-/**
- * Convert plural word to singular
- * @param {string} word - The word to singularize
- * @returns {string} - The singular form of the word
- */
-export function singularize(word) {
-    // Handle empty or short words
-    if (!word || word.length <= 1) {
-        return word;
-    }
-
-    // Check irregular singulars first
-    const lowerWord = word.toLowerCase();
-    if (IRREGULAR_SINGULARS[lowerWord]) {
-        return IRREGULAR_SINGULARS[lowerWord];
-    }
-
-    // Already singular (check exceptions)
-    if (SINGULAR_EXCEPTIONS.includes(lowerWord)) {
-        return word;
-    }
-
-    // -ies → -y (activities → activity)
-    if (word.endsWith('ies')) {
-        return word.slice(0, -3) + 'y';
-    }
-
-    // -ses → -s (processes → process, but 'process' is already singular)
-    // -xes → -x (boxes → box)
-    // -ches → -ch (watches → watch)
-    // -shes → -sh (dishes → dish)
-    if (word.endsWith('ses') || word.endsWith('xes') || word.endsWith('ches') || word.endsWith('shes')) {
-        return word.slice(0, -2);
-    }
-
-    // Regular -s ending (cats → cat)
-    // But avoid words ending in -ss (class, success, etc.)
-    if (word.endsWith('s') && !word.endsWith('ss') && word.length > 1) {
-        return word.slice(0, -1);
-    }
-
-    return word;
-}
-
-/**
- * Convert singular word to plural
- * @param {string} word - The word to pluralize
- * @returns {string} - The plural form of the word
- */
-export function pluralize(word) {
-    // Handle empty or short words
-    if (!word || word.length <= 1) {
-        return word;
-    }
-
-    // Check if already plural
-    if (isPlural(word)) {
-        return word;
-    }
-
-    // Check irregular plurals first
-    const lowerWord = word.toLowerCase();
-    if (IRREGULAR_PLURALS[lowerWord]) {
-        return IRREGULAR_PLURALS[lowerWord];
-    }
-
-    // -y ending (not vowel+y) → -ies (activity → activities)
-    if (word.endsWith('y') && !['ay', 'ey', 'iy', 'oy', 'uy'].includes(word.slice(-2))) {
-        return word.slice(0, -1) + 'ies';
-    }
-
-    // -x, -ch, -sh endings → add 'es' (box → boxes, watch → watches, dish → dishes)
-    if (word.endsWith('x') || word.endsWith('ch') || word.endsWith('sh')) {
-        return word + 'es';
-    }
-
-    // Regular: add 's' (cat → cats, dog → dogs)
-    return word + 's';
-}

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