@claudetools/tools 0.9.0 → 0.9.2

package/dist/codedna/kappa-laravel-generator.js

@@ -0,0 +1,741 @@
+// =============================================================================
+// Kappa v2.5 PHP/Laravel Generator
+// =============================================================================
+//
+// Generates Laravel code from Kappa specifications.
+// Supports: Controllers, Models, Migrations, Form Requests.
+//
+// =============================================================================
+// Type Mappings
+// =============================================================================
+const PRIMITIVE_PHP_MAP = {
+    string: 'string',
+    int: 'int',
+    float: 'float',
+    bool: 'bool',
+    timestamp: '\\Carbon\\Carbon',
+    date: '\\Carbon\\Carbon',
+    time: '\\Carbon\\Carbon',
+    duration: 'int',
+    uuid: 'string',
+    email: 'string',
+    url: 'string',
+    phone: 'string',
+    slug: 'string',
+    markdown: 'string',
+    json: 'array',
+};
+const PRIMITIVE_MIGRATION_MAP = {
+    string: 'string',
+    int: 'integer',
+    float: 'decimal',
+    bool: 'boolean',
+    timestamp: 'timestamp',
+    date: 'date',
+    time: 'time',
+    duration: 'integer',
+    uuid: 'uuid',
+    email: 'string',
+    url: 'string',
+    phone: 'string',
+    slug: 'string',
+    markdown: 'text',
+    json: 'json',
+};
+const PRIMITIVE_VALIDATION_MAP = {
+    string: ['string'],
+    int: ['integer'],
+    float: ['numeric'],
+    bool: ['boolean'],
+    timestamp: ['date'],
+    date: ['date'],
+    time: ['date_format:H:i:s'],
+    duration: ['integer'],
+    uuid: ['uuid'],
+    email: ['email'],
+    url: ['url'],
+    phone: ['string'],
+    slug: ['string', 'regex:/^[a-z0-9-]+$/'],
+    markdown: ['string'],
+    json: ['array'],
+};
+const CRUD_METHOD_MAP = {
+    create: 'post',
+    read: 'get',
+    update: 'patch',
+    delete: 'delete',
+    list: 'get',
+};
+const CRUD_ACTION_MAP = {
+    create: 'store',
+    read: 'show',
+    update: 'update',
+    delete: 'destroy',
+    list: 'index',
+};
+// =============================================================================
+// Generator Class
+// =============================================================================
+export class KappaLaravelGenerator {
+    modelNamespace;
+    controllerNamespace;
+    provenance;
+    migrations;
+    formRequests;
+    apiResources;
+    basePath;
+    entities;
+    constructor(options = {}) {
+        this.modelNamespace = options.modelNamespace ?? 'App\\Models';
+        this.controllerNamespace = options.controllerNamespace ?? 'App\\Http\\Controllers';
+        this.provenance = options.provenance ?? true;
+        this.migrations = options.migrations ?? true;
+        this.formRequests = options.formRequests ?? true;
+        this.apiResources = options.apiResources ?? true;
+        this.basePath = options.basePath ?? '/api';
+        this.entities = new Map();
+    }
+    // ===========================================================================
+    // Main Generation Methods
+    // ===========================================================================
+    generateFromAPIs(apis) {
+        const routes = this.extractRoutes(apis);
+        const controllers = {};
+        const formRequests = {};
+        // Group routes by controller
+        const controllerGroups = this.groupByController(routes);
+        for (const [controllerName, controllerRoutes] of Object.entries(controllerGroups)) {
+            controllers[controllerName] = this.generateController(controllerName, controllerRoutes);
+            if (this.formRequests) {
+                for (const route of controllerRoutes) {
+                    if (route.method === 'post' || route.method === 'put' || route.method === 'patch') {
+                        const requestName = `${this.toPascalCase(route.operationName)}Request`;
+                        formRequests[requestName] = this.generateFormRequest(requestName, route);
+                    }
+                }
+            }
+        }
+        return {
+            routes: this.generateRoutes(apis),
+            controllers,
+            models: {},
+            formRequests: this.formRequests ? formRequests : undefined,
+        };
+    }
+    generateFromEntities(entities) {
+        const models = {};
+        const migrations = {};
+        const resources = {};
+        for (const entity of entities) {
+            models[entity.name] = this.generateModel(entity);
+            if (this.migrations) {
+                const migrationName = `create_${this.toSnakeCase(entity.name)}s_table`;
+                migrations[migrationName] = this.generateMigration(entity);
+            }
+            if (this.apiResources) {
+                resources[`${entity.name}Resource`] = this.generateResource(entity);
+            }
+        }
+        return {
+            routes: '',
+            controllers: {},
+            models,
+            migrations: this.migrations ? migrations : undefined,
+            resources: this.apiResources ? resources : undefined,
+        };
+    }
+    generateAll(apis, entities) {
+        // Store entities for validation rule generation
+        for (const entity of entities) {
+            this.entities.set(entity.name, entity);
+        }
+        const apiResult = this.generateFromAPIs(apis);
+        const entityResult = this.generateFromEntities(entities);
+        return {
+            routes: apiResult.routes,
+            controllers: apiResult.controllers,
+            models: entityResult.models,
+            migrations: entityResult.migrations,
+            formRequests: apiResult.formRequests,
+            resources: entityResult.resources,
+        };
+    }
+    // ===========================================================================
+    // Route Generation
+    // ===========================================================================
+    generateRoutes(apis) {
+        const lines = [];
+        const routes = this.extractRoutes(apis);
+        // Header
+        lines.push('<?php');
+        lines.push('');
+        if (this.provenance) {
+            lines.push('// Generated by Kappa v2.5 CodeDNA');
+            lines.push('// Framework: Laravel');
+            lines.push('');
+        }
+        lines.push("use Illuminate\\Support\\Facades\\Route;");
+        // Collect controller imports
+        const controllers = new Set();
+        for (const route of routes) {
+            controllers.add(`use ${this.controllerNamespace}\\${route.controller};`);
+        }
+        for (const controller of controllers) {
+            lines.push(controller);
+        }
+        lines.push('');
+        // API routes
+        lines.push("Route::prefix('api')->group(function () {");
+        // Group by auth requirement
+        const authRoutes = routes.filter((r) => r.requiresAuth);
+        const publicRoutes = routes.filter((r) => !r.requiresAuth);
+        if (publicRoutes.length > 0) {
+            lines.push('    // Public routes');
+            for (const route of publicRoutes) {
+                lines.push(this.generateRouteDefinition(route));
+            }
+            lines.push('');
+        }
+        if (authRoutes.length > 0) {
+            lines.push("    Route::middleware(['auth:sanctum'])->group(function () {");
+            for (const route of authRoutes) {
+                lines.push('    ' + this.generateRouteDefinition(route));
+            }
+            lines.push('    });');
+        }
+        lines.push('});');
+        lines.push('');
+        return lines.join('\n');
+    }
+    generateRouteDefinition(route) {
+        const middleware = route.middleware.length > 0
+            ? `->middleware([${route.middleware.map((m) => `'${m}'`).join(', ')}])`
+            : '';
+        return `    Route::${route.method}('${route.path}', [${route.controller}::class, '${route.action}'])${middleware};`;
+    }
+    extractRoutes(apis) {
+        const routes = [];
+        for (const api of apis) {
+            const apiPath = `/${this.toKebabCase(api.name)}`;
+            const controllerName = `${api.name}Controller`;
+            for (const crud of api.crud || []) {
+                routes.push(...this.crudToRoutes(crud, apiPath, controllerName));
+            }
+            if (api.operations) {
+                for (const op of api.operations) {
+                    routes.push(this.operationToRoute(op, apiPath, controllerName));
+                }
+            }
+        }
+        return routes;
+    }
+    operationToRoute(op, apiPath, controller) {
+        const method = this.inferMethod(op.name);
+        const path = `${apiPath}/${this.toKebabCase(op.name)}`;
+        const middleware = [];
+        if (op.rateLimit) {
+            middleware.push(`throttle:${op.rateLimit}`);
+        }
+        return {
+            method,
+            path,
+            controller,
+            action: this.toCamelCase(op.name),
+            operationName: op.name,
+            effects: op.effects,
+            requiresAuth: op.effects.includes('Auth'),
+            middleware,
+        };
+    }
+    crudToRoutes(crud, apiPath, controller) {
+        const routes = [];
+        const entityPath = `${apiPath}/${this.toKebabCase(crud.entity)}s`;
+        for (const action of crud.actions) {
+            const method = CRUD_METHOD_MAP[action.action] ?? 'get';
+            const laravelAction = CRUD_ACTION_MAP[action.action] ?? action.action;
+            const pathSuffix = action.action === 'read' || action.action === 'update' || action.action === 'delete'
+                ? '/{id}'
+                : '';
+            routes.push({
+                method,
+                path: `${entityPath}${pathSuffix}`,
+                controller,
+                action: laravelAction,
+                operationName: `${action.action}${crud.entity}`,
+                effects: action.effects,
+                requiresAuth: action.effects.includes('Auth'),
+                middleware: [],
+            });
+        }
+        return routes;
+    }
+    inferMethod(name) {
+        const lower = name.toLowerCase();
+        if (lower.startsWith('get') ||
+            lower.startsWith('list') ||
+            lower.startsWith('find') ||
+            lower.startsWith('fetch')) {
+            return 'get';
+        }
+        if (lower.startsWith('create') || lower.startsWith('add') || lower.startsWith('register')) {
+            return 'post';
+        }
+        if (lower.startsWith('update') || lower.startsWith('edit')) {
+            return 'patch';
+        }
+        if (lower.startsWith('delete') || lower.startsWith('remove')) {
+            return 'delete';
+        }
+        return 'post';
+    }
+    groupByController(routes) {
+        const groups = {};
+        for (const route of routes) {
+            if (!groups[route.controller]) {
+                groups[route.controller] = [];
+            }
+            groups[route.controller].push(route);
+        }
+        return groups;
+    }
+    // ===========================================================================
+    // Controller Generation
+    // ===========================================================================
+    generateController(name, routes) {
+        const lines = [];
+        lines.push('<?php');
+        lines.push('');
+        lines.push(`namespace ${this.controllerNamespace};`);
+        lines.push('');
+        if (this.provenance) {
+            lines.push('// Generated by Kappa v2.5 CodeDNA');
+            lines.push('');
+        }
+        lines.push('use Illuminate\\Http\\JsonResponse;');
+        lines.push('use Illuminate\\Http\\Request;');
+        lines.push('');
+        lines.push(`class ${name} extends Controller`);
+        lines.push('{');
+        for (const route of routes) {
+            lines.push(this.generateControllerMethod(route));
+            lines.push('');
+        }
+        lines.push('}');
+        lines.push('');
+        return lines.join('\n');
+    }
+    generateControllerMethod(route) {
+        const lines = [];
+        const paramType = route.method === 'post' || route.method === 'put' || route.method === 'patch'
+            ? `${this.toPascalCase(route.operationName)}Request`
+            : 'Request';
+        lines.push('    /**');
+        lines.push(`     * ${route.operationName}`);
+        if (route.effects.length > 0) {
+            lines.push(`     * Effects: ${route.effects.join(', ')}`);
+        }
+        lines.push('     */');
+        lines.push(`    public function ${route.action}(${paramType} $request): JsonResponse`);
+        lines.push('    {');
+        lines.push(`        // TODO: Implement ${route.operationName}`);
+        lines.push('        return response()->json([');
+        lines.push("            'message' => 'Not implemented',");
+        lines.push('        ], 501);');
+        lines.push('    }');
+        return lines.join('\n');
+    }
+    // ===========================================================================
+    // Model Generation
+    // ===========================================================================
+    generateModel(entity) {
+        const lines = [];
+        lines.push('<?php');
+        lines.push('');
+        lines.push(`namespace ${this.modelNamespace};`);
+        lines.push('');
+        if (this.provenance) {
+            lines.push('// Generated by Kappa v2.5 CodeDNA');
+            lines.push('');
+        }
+        lines.push('use Illuminate\\Database\\Eloquent\\Factories\\HasFactory;');
+        lines.push('use Illuminate\\Database\\Eloquent\\Model;');
+        // Check for UUID
+        const hasUUID = entity.fields.some((f) => f.type.kind === 'primitive' && f.type.type === 'uuid');
+        if (hasUUID) {
+            lines.push('use Illuminate\\Database\\Eloquent\\Concerns\\HasUuids;');
+        }
+        lines.push('');
+        lines.push(`class ${entity.name} extends Model`);
+        lines.push('{');
+        lines.push('    use HasFactory;');
+        if (hasUUID) {
+            lines.push('    use HasUuids;');
+        }
+        lines.push('');
+        // Table name
+        lines.push(`    protected $table = '${this.toSnakeCase(entity.name)}s';`);
+        lines.push('');
+        // Fillable
+        const fillable = entity.fields
+            .filter((f) => !f.modifiers.includes('primary') && !f.modifiers.includes('auto'))
+            .map((f) => `'${this.toSnakeCase(f.name)}'`);
+        lines.push('    protected $fillable = [');
+        lines.push(`        ${fillable.join(',\n        ')},`);
+        lines.push('    ];');
+        lines.push('');
+        // Hidden
+        const hidden = entity.fields
+            .filter((f) => f.modifiers.includes('hashed') || f.name.toLowerCase().includes('password'))
+            .map((f) => `'${this.toSnakeCase(f.name)}'`);
+        if (hidden.length > 0) {
+            lines.push('    protected $hidden = [');
+            lines.push(`        ${hidden.join(',\n        ')},`);
+            lines.push('    ];');
+            lines.push('');
+        }
+        // Casts
+        const casts = this.generateCasts(entity.fields);
+        if (Object.keys(casts).length > 0) {
+            lines.push('    protected $casts = [');
+            for (const [field, type] of Object.entries(casts)) {
+                lines.push(`        '${field}' => '${type}',`);
+            }
+            lines.push('    ];');
+        }
+        lines.push('}');
+        lines.push('');
+        return lines.join('\n');
+    }
+    generateCasts(fields) {
+        const casts = {};
+        for (const field of fields) {
+            const fieldName = this.toSnakeCase(field.name);
+            if (field.type.kind === 'primitive') {
+                switch (field.type.type) {
+                    case 'timestamp':
+                    case 'date':
+                        casts[fieldName] = 'datetime';
+                        break;
+                    case 'bool':
+                        casts[fieldName] = 'boolean';
+                        break;
+                    case 'int':
+                        casts[fieldName] = 'integer';
+                        break;
+                    case 'float':
+                        casts[fieldName] = 'float';
+                        break;
+                    case 'json':
+                        casts[fieldName] = 'array';
+                        break;
+                }
+            }
+            else if (field.type.kind === 'array') {
+                casts[fieldName] = 'array';
+            }
+            // Handle hashed modifier for password-like fields
+            if (field.modifiers.includes('hashed')) {
+                casts[fieldName] = 'hashed';
+            }
+        }
+        return casts;
+    }
+    // ===========================================================================
+    // Migration Generation
+    // ===========================================================================
+    generateMigration(entity) {
+        const lines = [];
+        const tableName = `${this.toSnakeCase(entity.name)}s`;
+        lines.push('<?php');
+        lines.push('');
+        if (this.provenance) {
+            lines.push('// Generated by Kappa v2.5 CodeDNA');
+            lines.push('');
+        }
+        lines.push('use Illuminate\\Database\\Migrations\\Migration;');
+        lines.push('use Illuminate\\Database\\Schema\\Blueprint;');
+        lines.push('use Illuminate\\Support\\Facades\\Schema;');
+        lines.push('');
+        lines.push('return new class extends Migration');
+        lines.push('{');
+        lines.push('    public function up(): void');
+        lines.push('    {');
+        lines.push(`        Schema::create('${tableName}', function (Blueprint $table) {`);
+        // Check for custom primary key
+        const hasPrimary = entity.fields.some((f) => f.modifiers.includes('primary'));
+        const hasUUID = entity.fields.some((f) => f.type.kind === 'primitive' && f.type.type === 'uuid' && f.modifiers.includes('primary'));
+        if (!hasPrimary) {
+            lines.push('            $table->id();');
+        }
+        for (const field of entity.fields) {
+            const migration = this.generateMigrationColumn(field);
+            if (migration) {
+                lines.push(`            ${migration}`);
+            }
+        }
+        lines.push('            $table->timestamps();');
+        lines.push('        });');
+        lines.push('    }');
+        lines.push('');
+        lines.push('    public function down(): void');
+        lines.push('    {');
+        lines.push(`        Schema::dropIfExists('${tableName}');`);
+        lines.push('    }');
+        lines.push('};');
+        lines.push('');
+        return lines.join('\n');
+    }
+    generateMigrationColumn(field) {
+        const columnName = this.toSnakeCase(field.name);
+        let type;
+        let modifiers = [];
+        if (field.type.kind === 'primitive') {
+            type = PRIMITIVE_MIGRATION_MAP[field.type.type] ?? 'string';
+            if (field.type.type === 'uuid' && field.modifiers.includes('primary')) {
+                return `$table->uuid('${columnName}')->primary();`;
+            }
+        }
+        else if (field.type.kind === 'enum') {
+            const values = field.type.values.map((v) => `'${v}'`).join(', ');
+            return `$table->enum('${columnName}', [${values}]);`;
+        }
+        else if (field.type.kind === 'array') {
+            type = 'json';
+        }
+        else if (field.type.kind === 'reference') {
+            // Foreign key - use foreignUuid if the referenced entity uses UUID
+            const refTable = `${this.toSnakeCase(field.type.entity)}s`;
+            // For now, assume UUID foreign keys (most common in modern Laravel)
+            // TODO: Could enhance to detect if referenced entity uses UUID or int
+            return `$table->foreignUuid('${columnName}')->constrained('${refTable}');`;
+        }
+        else {
+            return null;
+        }
+        // Apply modifiers
+        if (field.modifiers.includes('unique')) {
+            modifiers.push('unique()');
+        }
+        if (field.modifiers.includes('optional')) {
+            modifiers.push('nullable()');
+        }
+        if (field.defaultValue !== undefined) {
+            // Handle boolean literals correctly
+            if (field.type.kind === 'primitive' && field.type.type === 'bool') {
+                modifiers.push(`default(${field.defaultValue})`);
+            }
+            else if (typeof field.defaultValue === 'number') {
+                modifiers.push(`default(${field.defaultValue})`);
+            }
+            else {
+                modifiers.push(`default('${field.defaultValue}')`);
+            }
+        }
+        const modifierStr = modifiers.length > 0 ? '->' + modifiers.join('->') : '';
+        return `$table->${type}('${columnName}')${modifierStr};`;
+    }
+    // ===========================================================================
+    // Form Request Generation
+    // ===========================================================================
+    generateFormRequest(name, route) {
+        const lines = [];
+        lines.push('<?php');
+        lines.push('');
+        lines.push('namespace App\\Http\\Requests;');
+        lines.push('');
+        if (this.provenance) {
+            lines.push('// Generated by Kappa v2.5 CodeDNA');
+            lines.push('');
+        }
+        lines.push('use Illuminate\\Foundation\\Http\\FormRequest;');
+        lines.push('');
+        lines.push(`class ${name} extends FormRequest`);
+        lines.push('{');
+        lines.push('    public function authorize(): bool');
+        lines.push('    {');
+        lines.push(`        return ${route.requiresAuth ? 'auth()->check()' : 'true'};`);
+        lines.push('    }');
+        lines.push('');
+        lines.push('    public function rules(): array');
+        lines.push('    {');
+        lines.push('        return [');
+        // Try to extract entity name from route to generate validation rules
+        const validationRules = this.generateValidationRules(route);
+        if (validationRules.length > 0) {
+            for (const rule of validationRules) {
+                lines.push(`            ${rule}`);
+            }
+        }
+        else {
+            lines.push('            // TODO: Add validation rules');
+        }
+        lines.push('        ];');
+        lines.push('    }');
+        lines.push('}');
+        lines.push('');
+        return lines.join('\n');
+    }
+    generateValidationRules(route) {
+        const rules = [];
+        // Try to infer entity from route operation name
+        // e.g., "createPost" -> "Post", "updateUser" -> "User"
+        let entityName = null;
+        for (const [name] of this.entities) {
+            if (route.operationName.toLowerCase().includes(name.toLowerCase())) {
+                entityName = name;
+                break;
+            }
+        }
+        if (!entityName) {
+            return rules;
+        }
+        const entity = this.entities.get(entityName);
+        if (!entity) {
+            return rules;
+        }
+        const isUpdate = route.action === 'update' || route.operationName.toLowerCase().includes('update');
+        for (const field of entity.fields) {
+            // Skip primary keys and auto-generated fields
+            if (field.modifiers.includes('primary') || field.modifiers.includes('auto')) {
+                continue;
+            }
+            const fieldName = this.toSnakeCase(field.name);
+            const fieldRules = [];
+            // Required/optional
+            if (isUpdate) {
+                fieldRules.push('sometimes');
+            }
+            else if (!field.modifiers.includes('optional')) {
+                fieldRules.push('required');
+            }
+            else {
+                fieldRules.push('nullable');
+            }
+            // Type-specific validation
+            if (field.type.kind === 'primitive') {
+                const primitiveRules = PRIMITIVE_VALIDATION_MAP[field.type.type] || [];
+                fieldRules.push(...primitiveRules);
+            }
+            else if (field.type.kind === 'enum') {
+                fieldRules.push(`in:${field.type.values.join(',')}`);
+            }
+            else if (field.type.kind === 'reference') {
+                const refTable = `${this.toSnakeCase(field.type.entity)}s`;
+                fieldRules.push(`exists:${refTable},id`);
+            }
+            // Modifiers
+            if (field.modifiers.includes('unique')) {
+                const tableName = `${this.toSnakeCase(entityName)}s`;
+                if (isUpdate) {
+                    // For updates, we need to exclude the current record from unique check
+                    // This will be concatenated in the rules array, not interpolated here
+                    rules.push(`'${fieldName}' => ['${fieldRules.join('\', \'')}', 'unique:${tableName},${fieldName},' . $this->route('id')],`);
+                    continue; // Skip the normal rule addition at the end
+                }
+                else {
+                    fieldRules.push(`unique:${tableName},${fieldName}`);
+                }
+            }
+            // Validators from field type range (if primitive with range constraint)
+            if (field.type.kind === 'primitive' && 'range' in field.type && field.type.range) {
+                const range = field.type.range;
+                if (range.min !== undefined) {
+                    fieldRules.push(`min:${range.min}`);
+                }
+                if (range.max !== undefined) {
+                    fieldRules.push(`max:${range.max}`);
+                }
+            }
+            rules.push(`'${fieldName}' => '${fieldRules.join('|')}',`);
+        }
+        return rules;
+    }
+    // ===========================================================================
+    // Resource Generation
+    // ===========================================================================
+    generateResource(entity) {
+        const lines = [];
+        lines.push('<?php');
+        lines.push('');
+        lines.push('namespace App\\Http\\Resources;');
+        lines.push('');
+        if (this.provenance) {
+            lines.push('// Generated by Kappa v2.5 CodeDNA');
+            lines.push('');
+        }
+        lines.push('use Illuminate\\Http\\Request;');
+        lines.push('use Illuminate\\Http\\Resources\\Json\\JsonResource;');
+        lines.push('');
+        lines.push(`class ${entity.name}Resource extends JsonResource`);
+        lines.push('{');
+        lines.push('    public function toArray(Request $request): array');
+        lines.push('    {');
+        lines.push('        return [');
+        const addedFields = new Set();
+        for (const field of entity.fields) {
+            const fieldName = this.toSnakeCase(field.name);
+            // Skip password fields in resources
+            if (field.modifiers.includes('hashed') || field.name.toLowerCase().includes('password')) {
+                continue;
+            }
+            // Skip auto timestamp fields (created_at, updated_at) - we'll add them at the end
+            if (field.modifiers.includes('auto') && (fieldName === 'created_at' || fieldName === 'updated_at')) {
+                continue;
+            }
+            lines.push(`            '${fieldName}' => $this->${fieldName},`);
+            addedFields.add(fieldName);
+        }
+        // Add timestamps if not already added
+        if (!addedFields.has('created_at')) {
+            lines.push("            'created_at' => $this->created_at,");
+        }
+        if (!addedFields.has('updated_at')) {
+            lines.push("            'updated_at' => $this->updated_at,");
+        }
+        lines.push('        ];');
+        lines.push('    }');
+        lines.push('}');
+        lines.push('');
+        return lines.join('\n');
+    }
+    // ===========================================================================
+    // Utility Methods
+    // ===========================================================================
+    toPascalCase(str) {
+        return str
+            .replace(/[-_](.)/g, (_, c) => c.toUpperCase())
+            .replace(/^(.)/, (_, c) => c.toUpperCase());
+    }
+    toCamelCase(str) {
+        return str
+            .replace(/[-_](.)/g, (_, c) => c.toUpperCase())
+            .replace(/^(.)/, (_, c) => c.toLowerCase());
+    }
+    toKebabCase(str) {
+        return str
+            .replace(/([a-z])([A-Z])/g, '$1-$2')
+            .replace(/[_\s]+/g, '-')
+            .toLowerCase();
+    }
+    toSnakeCase(str) {
+        return str
+            .replace(/([a-z])([A-Z])/g, '$1_$2')
+            .replace(/[-\s]+/g, '_')
+            .toLowerCase();
+    }
+}
+// =============================================================================
+// Convenience Functions
+// =============================================================================
+export function generateLaravelAPI(apis, options) {
+    const generator = new KappaLaravelGenerator(options);
+    return generator.generateFromAPIs(apis);
+}
+export function generateLaravelModels(entities, options) {
+    const generator = new KappaLaravelGenerator(options);
+    return generator.generateFromEntities(entities);
+}
+export function generateLaravel(apis, entities, options) {
+    const generator = new KappaLaravelGenerator(options);
+    return generator.generateAll(apis, entities);
+}