@veloxts/cli 0.7.2 → 0.7.4

package/dist/sync/index.js

@@ -0,0 +1,302 @@
+/**
+ * Sync Orchestrator
+ *
+ * Wires together the 5-stage `velox sync` pipeline:
+ * 1. Analyze Prisma schema -> SyncModelInfo[]
+ * 2. Detect existing code   -> ExistingCodeMap
+ * 3. Prompt user for choices -> ModelChoices[]
+ * 4. Build generation plan   -> SyncPlan
+ * 5. Generate files + register in router
+ *
+ * Supports --dry-run, --force, and --skip-registration flags.
+ */
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, relative } from 'node:path';
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { registerProcedures } from '../generators/utils/router-integration.js';
+import { executeWithRollback, saveOriginal, trackCreated } from '../generators/utils/snapshot.js';
+import { analyzeSchema } from './analyzer.js';
+import { detectExisting } from './detector.js';
+import { buildPlan } from './planner.js';
+import { generateProcedureFile } from './procedure-generator.js';
+import { promptAllModels } from './prompter.js';
+import { generateSchemaFile } from './schema-generator.js';
+// ============================================================================
+// Public API
+// ============================================================================
+/**
+ * Execute the full sync pipeline.
+ *
+ * @param projectRoot - Absolute path to the project root directory
+ * @param options     - CLI flags (dryRun, force, skipRegistration)
+ * @returns Summary of files created, overwritten, skipped, registered, and errors
+ */
+export async function executeSync(projectRoot, options) {
+    // ── Stage 1: Analyze ────────────────────────────────────────
+    const models = analyzeSchema(projectRoot);
+    if (models.length === 0) {
+        p.log.warn('No models found in Prisma schema. Nothing to sync.');
+        return emptyResult();
+    }
+    // ── Stage 2: Detect ─────────────────────────────────────────
+    const existing = detectExisting(projectRoot, models);
+    // Show discovery summary
+    const existingProcCount = existing.procedures.size;
+    const existingSchemaCount = existing.schemas.size;
+    p.log.info(`Found ${pc.cyan(String(models.length))} model${models.length === 1 ? '' : 's'}` +
+        (existingProcCount > 0 || existingSchemaCount > 0
+            ? ` (${existingProcCount} existing procedure${existingProcCount === 1 ? '' : 's'}, ` +
+                `${existingSchemaCount} existing schema${existingSchemaCount === 1 ? '' : 's'})`
+            : ''));
+    // ── Stage 3: Prompt ─────────────────────────────────────────
+    let choices;
+    if (options.force) {
+        choices = models.map((model) => buildDefaultChoices(model));
+    }
+    else {
+        const prompted = await promptAllModels(models, existing);
+        if (prompted === null) {
+            p.log.warn('Cancelled.');
+            return emptyResult();
+        }
+        choices = prompted;
+    }
+    // Check if anything was selected
+    const activeChoices = choices.filter((c) => c.action !== 'skip');
+    if (activeChoices.length === 0) {
+        p.log.warn('All models skipped. Nothing to generate.');
+        return emptyResult();
+    }
+    // ── Stage 4: Plan ───────────────────────────────────────────
+    const plan = buildPlan(models, choices, projectRoot);
+    // Show plan summary
+    displayPlanSummary(plan, projectRoot);
+    // Dry run: show plan and exit
+    if (options.dryRun) {
+        p.log.info(pc.dim('Dry run — no files were written.'));
+        return buildDryRunResult(plan);
+    }
+    // Confirm before writing (unless --force)
+    if (!options.force) {
+        const totalFiles = plan.schemas.length + plan.procedures.length;
+        const confirmed = await p.confirm({
+            message: `Generate ${totalFiles} file${totalFiles === 1 ? '' : 's'}?`,
+            initialValue: true,
+        });
+        if (p.isCancel(confirmed) || !confirmed) {
+            p.log.warn('Cancelled.');
+            return emptyResult();
+        }
+    }
+    // ── Stage 5: Generate ───────────────────────────────────────
+    return executeWithRollback(async (snapshot) => {
+        return generateFiles(snapshot, plan, projectRoot, options);
+    });
+}
+// ============================================================================
+// File Generation
+// ============================================================================
+/**
+ * Generate all planned files within a snapshot transaction.
+ */
+async function generateFiles(snapshot, plan, projectRoot, options) {
+    const created = [];
+    const overwritten = [];
+    const skipped = [];
+    const registered = [];
+    const errors = [];
+    // ── Write schema files ──────────────────────────────────────
+    for (const schemaPlan of plan.schemas) {
+        try {
+            const content = generateSchemaFile(schemaPlan);
+            const outputPath = schemaPlan.outputPath;
+            mkdirSync(dirname(outputPath), { recursive: true });
+            if (schemaPlan.action === 'overwrite' && existsSync(outputPath)) {
+                saveOriginal(snapshot, outputPath);
+                writeFileSync(outputPath, content, 'utf-8');
+                overwritten.push(outputPath);
+            }
+            else {
+                writeFileSync(outputPath, content, 'utf-8');
+                trackCreated(snapshot, outputPath);
+                created.push(outputPath);
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            errors.push(`Schema ${schemaPlan.model.name}: ${msg}`);
+        }
+    }
+    // ── Write procedure files ───────────────────────────────────
+    for (const procPlan of plan.procedures) {
+        try {
+            const content = generateProcedureFile(procPlan);
+            const outputPath = procPlan.outputPath;
+            mkdirSync(dirname(outputPath), { recursive: true });
+            if (procPlan.action === 'overwrite' && existsSync(outputPath)) {
+                saveOriginal(snapshot, outputPath);
+                writeFileSync(outputPath, content, 'utf-8');
+                overwritten.push(outputPath);
+            }
+            else {
+                writeFileSync(outputPath, content, 'utf-8');
+                trackCreated(snapshot, outputPath);
+                created.push(outputPath);
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            errors.push(`Procedure ${procPlan.model.name}: ${msg}`);
+        }
+    }
+    // ── Register procedures in router ───────────────────────────
+    if (!options.skipRegistration) {
+        for (const reg of plan.registrations) {
+            try {
+                const result = registerProcedures(projectRoot, reg.entityName, reg.procedureVarName, false);
+                if (result.success) {
+                    registered.push(reg.procedureVarName);
+                }
+                else if (result.error) {
+                    errors.push(`Registration ${reg.procedureVarName}: ${result.error}`);
+                }
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                errors.push(`Registration ${reg.procedureVarName}: ${msg}`);
+            }
+        }
+    }
+    // ── Display results ─────────────────────────────────────────
+    displayResults(created, overwritten, registered, errors, projectRoot);
+    return { created, overwritten, skipped, registered, errors };
+}
+// ============================================================================
+// Display Helpers
+// ============================================================================
+/**
+ * Display a summary of the generation plan before executing.
+ */
+function displayPlanSummary(plan, projectRoot) {
+    const lines = [];
+    if (plan.schemas.length > 0) {
+        lines.push(pc.bold('Schemas:'));
+        for (const s of plan.schemas) {
+            const rel = relative(projectRoot, s.outputPath);
+            const tag = s.action === 'overwrite' ? pc.yellow('overwrite') : pc.green('create');
+            lines.push(`  ${tag}  ${rel}`);
+        }
+    }
+    if (plan.procedures.length > 0) {
+        lines.push(pc.bold('Procedures:'));
+        for (const proc of plan.procedures) {
+            const rel = relative(projectRoot, proc.outputPath);
+            const tag = proc.action === 'overwrite' ? pc.yellow('overwrite') : pc.green('create');
+            lines.push(`  ${tag}  ${rel}`);
+        }
+    }
+    if (plan.registrations.length > 0) {
+        lines.push(pc.bold('Registrations:'));
+        for (const reg of plan.registrations) {
+            lines.push(`  ${pc.cyan('register')}  ${reg.procedureVarName} -> ${reg.importPath}`);
+        }
+    }
+    if (lines.length > 0) {
+        p.log.info(lines.join('\n'));
+    }
+}
+/**
+ * Display the final results after generation.
+ */
+function displayResults(created, overwritten, registered, errors, projectRoot) {
+    if (created.length > 0) {
+        for (const filePath of created) {
+            p.log.success(`${pc.green('created')}  ${relative(projectRoot, filePath)}`);
+        }
+    }
+    if (overwritten.length > 0) {
+        for (const filePath of overwritten) {
+            p.log.success(`${pc.yellow('overwritten')}  ${relative(projectRoot, filePath)}`);
+        }
+    }
+    if (registered.length > 0) {
+        for (const name of registered) {
+            p.log.success(`${pc.cyan('registered')}  ${name}`);
+        }
+    }
+    if (errors.length > 0) {
+        for (const msg of errors) {
+            p.log.error(msg);
+        }
+    }
+}
+// ============================================================================
+// Default Choices (--force mode)
+// ============================================================================
+/**
+ * Build default ModelChoices for a model (used when --force is set).
+ * Generates all CRUD, uses output strategy, includes no relations.
+ */
+function buildDefaultChoices(model) {
+    return {
+        model: model.name,
+        action: 'generate',
+        outputStrategy: 'output',
+        crud: {
+            get: true,
+            list: true,
+            create: true,
+            update: true,
+            delete: true,
+        },
+        schemaRelations: [],
+        includeRelations: [],
+        fieldVisibility: undefined,
+    };
+}
+// ============================================================================
+// Result Helpers
+// ============================================================================
+/**
+ * Build an empty SyncResult (for cancellation or no-op cases).
+ */
+function emptyResult() {
+    return {
+        created: [],
+        overwritten: [],
+        skipped: [],
+        registered: [],
+        errors: [],
+    };
+}
+/**
+ * Build a SyncResult for dry-run mode (no files written).
+ */
+function buildDryRunResult(plan) {
+    const created = [];
+    const overwritten = [];
+    for (const s of plan.schemas) {
+        if (s.action === 'overwrite') {
+            overwritten.push(s.outputPath);
+        }
+        else {
+            created.push(s.outputPath);
+        }
+    }
+    for (const proc of plan.procedures) {
+        if (proc.action === 'overwrite') {
+            overwritten.push(proc.outputPath);
+        }
+        else {
+            created.push(proc.outputPath);
+        }
+    }
+    return {
+        created,
+        overwritten,
+        skipped: [],
+        registered: plan.registrations.map((r) => r.procedureVarName),
+        errors: [],
+    };
+}

package/dist/sync/planner.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Sync Planner
+ *
+ * Transforms user choices from the prompter stage into a concrete
+ * generation plan consumed by the generator stage.
+ *
+ * For each model the user chose to generate or regenerate, the planner
+ * computes output paths, import paths, field/relation filtering, and
+ * router registration metadata.
+ */
+import type { ModelChoices, SyncModelInfo, SyncPlan } from './types.js';
+/**
+ * Build a complete generation plan from analyzer models and user choices.
+ *
+ * Skipped models produce no plan entries. For each non-skipped model,
+ * the planner produces a schema file plan, a procedure file plan,
+ * and a router registration plan.
+ *
+ * @param models    - Model metadata from the analyzer stage
+ * @param choices   - User selections from the prompter stage
+ * @param projectRoot - Absolute path to the project root directory
+ * @returns A complete plan ready for the generator stage
+ */
+export declare function buildPlan(models: readonly SyncModelInfo[], choices: readonly ModelChoices[], projectRoot: string): SyncPlan;

package/dist/sync/planner.js

@@ -0,0 +1,75 @@
+/**
+ * Sync Planner
+ *
+ * Transforms user choices from the prompter stage into a concrete
+ * generation plan consumed by the generator stage.
+ *
+ * For each model the user chose to generate or regenerate, the planner
+ * computes output paths, import paths, field/relation filtering, and
+ * router registration metadata.
+ */
+import { join } from 'node:path';
+import { deriveEntityNames, toKebabCase } from '../generators/utils/naming.js';
+/**
+ * Build a complete generation plan from analyzer models and user choices.
+ *
+ * Skipped models produce no plan entries. For each non-skipped model,
+ * the planner produces a schema file plan, a procedure file plan,
+ * and a router registration plan.
+ *
+ * @param models    - Model metadata from the analyzer stage
+ * @param choices   - User selections from the prompter stage
+ * @param projectRoot - Absolute path to the project root directory
+ * @returns A complete plan ready for the generator stage
+ */
+export function buildPlan(models, choices, projectRoot) {
+    const schemas = [];
+    const procedures = [];
+    const registrations = [];
+    for (const choice of choices) {
+        if (choice.action === 'skip') {
+            continue;
+        }
+        const names = deriveEntityNames(choice.model);
+        const model = models.find((m) => m.name === choice.model);
+        if (!model) {
+            continue;
+        }
+        const fileAction = choice.action === 'regenerate' ? 'overwrite' : 'create';
+        const pluralKebab = toKebabCase(names.plural);
+        // ── Schema file plan ──────────────────────────────────────────────
+        const allFields = model.fields;
+        const fields = allFields.filter((f) => !f.isAutoManaged && !f.isSensitive);
+        const relations = model.relations.filter((r) => choice.schemaRelations.includes(r.name));
+        schemas.push({
+            model,
+            outputPath: join(projectRoot, 'src/schemas', `${names.kebab}.schema.ts`),
+            outputStrategy: choice.outputStrategy,
+            allFields,
+            fields,
+            relations,
+            fieldVisibility: choice.fieldVisibility,
+            action: fileAction,
+        });
+        // ── Procedure file plan ───────────────────────────────────────────
+        const includeRelations = model.relations
+            .filter((r) => choice.includeRelations.includes(r.name))
+            .map((r) => r.name);
+        procedures.push({
+            model,
+            outputPath: join(projectRoot, 'src/procedures', `${pluralKebab}.ts`),
+            schemaImportPath: `../schemas/${names.kebab}.schema.js`,
+            outputStrategy: choice.outputStrategy,
+            crud: choice.crud,
+            includeRelations,
+            action: fileAction,
+        });
+        // ── Registration plan ─────────────────────────────────────────────
+        registrations.push({
+            procedureVarName: `${names.camel}Procedures`,
+            entityName: pluralKebab,
+            importPath: `./procedures/${pluralKebab}.js`,
+        });
+    }
+    return { schemas, procedures, registrations };
+}

package/dist/sync/procedure-generator.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Sync Procedure Generator
+ *
+ * Generates complete TypeScript source for procedure files from a
+ * `ProcedureFilePlan`. Supports two output strategies:
+ *
+ * - `output`: Procedures use `.output()` with plain Zod schemas
+ * - `resource`: Procedures use `resource()` / `resourceCollection()` projection
+ *
+ * Both strategies generate CRUD procedures based on `plan.crud` flags.
+ */
+import type { ProcedureFilePlan } from './types.js';
+/**
+ * Generate a complete TypeScript source string for a procedure file.
+ *
+ * The output is a syntactically valid TypeScript module containing:
+ * - Imports (router, zod, schemas)
+ * - A procedures collection with CRUD operations based on plan.crud
+ */
+export declare function generateProcedureFile(plan: ProcedureFilePlan): string;

package/dist/sync/procedure-generator.js

@@ -0,0 +1,253 @@
+/**
+ * Sync Procedure Generator
+ *
+ * Generates complete TypeScript source for procedure files from a
+ * `ProcedureFilePlan`. Supports two output strategies:
+ *
+ * - `output`: Procedures use `.output()` with plain Zod schemas
+ * - `resource`: Procedures use `resource()` / `resourceCollection()` projection
+ *
+ * Both strategies generate CRUD procedures based on `plan.crud` flags.
+ */
+import { deriveEntityNames, toKebabCase } from '../generators/utils/naming.js';
+// ============================================================================
+// Public API
+// ============================================================================
+/**
+ * Generate a complete TypeScript source string for a procedure file.
+ *
+ * The output is a syntactically valid TypeScript module containing:
+ * - Imports (router, zod, schemas)
+ * - A procedures collection with CRUD operations based on plan.crud
+ */
+export function generateProcedureFile(plan) {
+    const names = deriveEntityNames(plan.model.name);
+    const lines = [];
+    // ── Imports ──────────────────────────────────────────
+    lines.push(generateImports(plan, names.pascal, names.pascalPlural));
+    lines.push('');
+    // ── Procedures Collection ───────────────────────────
+    lines.push(generateProceduresCollection(plan, names));
+    // Ensure trailing newline
+    return `${lines.join('\n')}\n`;
+}
+function generateImports(plan, pascal, pascalPlural) {
+    const lines = [];
+    // Router imports
+    const routerImports = ['procedure', 'procedures'];
+    if (plan.outputStrategy === 'resource') {
+        if (plan.crud.get) {
+            routerImports.push('resource');
+        }
+        if (plan.crud.list) {
+            routerImports.push('resourceCollection');
+        }
+    }
+    lines.push(`import { ${routerImports.join(', ')} } from '@veloxts/router';`);
+    // Zod import
+    lines.push("import { z } from 'zod';");
+    // Schema imports
+    const schemaNames = buildSchemaImportNames(plan, pascal, pascalPlural);
+    if (schemaNames.length > 0) {
+        lines.push(`import {\n  ${schemaNames.join(',\n  ')},\n} from '${plan.schemaImportPath}';`);
+    }
+    return lines.join('\n');
+}
+function buildSchemaImportNames(plan, pascal, pascalPlural) {
+    const schemas = [];
+    if (plan.outputStrategy === 'output') {
+        // Output strategy: import base or WithRelations schema
+        if (plan.crud.get || plan.crud.list) {
+            if (plan.includeRelations.length > 0) {
+                schemas.push(`${pascal}WithRelationsSchema`);
+            }
+            else {
+                schemas.push(`${pascal}Schema`);
+            }
+        }
+    }
+    else {
+        // Resource strategy: import base schema (for resource projection)
+        if (plan.crud.get || plan.crud.list) {
+            schemas.push(`${pascal}Schema`);
+        }
+    }
+    if (plan.crud.create) {
+        schemas.push(`Create${pascal}Schema`);
+    }
+    if (plan.crud.update) {
+        schemas.push(`Update${pascal}Schema`);
+    }
+    if (plan.crud.list) {
+        schemas.push(`List${pascalPlural}Schema`);
+    }
+    return schemas;
+}
+// ============================================================================
+// Procedures Collection
+// ============================================================================
+function generateProceduresCollection(plan, names) {
+    const routerName = toKebabCase(names.plural);
+    const collectionVar = `${names.camel}Procedures`;
+    const procedureEntries = [];
+    if (plan.crud.get) {
+        procedureEntries.push(generateGetProcedure(plan, names));
+    }
+    if (plan.crud.list) {
+        procedureEntries.push(generateListProcedure(plan, names));
+    }
+    if (plan.crud.create) {
+        procedureEntries.push(generateCreateProcedure(plan, names));
+    }
+    if (plan.crud.update) {
+        procedureEntries.push(generateUpdateProcedure(plan, names));
+    }
+    if (plan.crud.delete) {
+        procedureEntries.push(generateDeleteProcedure(plan, names));
+    }
+    const lines = [];
+    lines.push(`export const ${collectionVar} = procedures('${routerName}', {`);
+    lines.push(procedureEntries.join('\n\n'));
+    lines.push('});');
+    return lines.join('\n');
+}
+// ============================================================================
+// Individual Procedure Generators
+// ============================================================================
+function generateGetProcedure(plan, names) {
+    const procName = `get${names.pascal}`;
+    const hasIncludes = plan.includeRelations.length > 0;
+    const lines = [];
+    lines.push(`  ${procName}: procedure()`);
+    lines.push(`    .input(z.object({ id: z.string().uuid() }))`);
+    if (plan.outputStrategy === 'output') {
+        const schemaName = hasIncludes ? `${names.pascal}WithRelationsSchema` : `${names.pascal}Schema`;
+        lines.push(`    .output(${schemaName})`);
+        lines.push(`    .query(async ({ input, ctx }) => {`);
+        lines.push(`      return ctx.db.${names.camel}.findUniqueOrThrow({`);
+        lines.push(`        where: { id: input.id },`);
+        if (hasIncludes) {
+            lines.push(generateIncludeBlock(plan.includeRelations, 8));
+        }
+        lines.push(`      });`);
+        lines.push(`    }),`);
+    }
+    else {
+        // Resource strategy: no .output(), use resource()
+        lines.push(`    .query(async ({ input, ctx }) => {`);
+        lines.push(`      const ${names.camel} = await ctx.db.${names.camel}.findUniqueOrThrow({`);
+        lines.push(`        where: { id: input.id },`);
+        if (hasIncludes) {
+            lines.push(generateIncludeBlock(plan.includeRelations, 8));
+        }
+        lines.push(`      });`);
+        lines.push(`      return resource(${names.camel}, ${names.pascal}Schema.public);`);
+        lines.push(`    }),`);
+    }
+    return lines.join('\n');
+}
+function generateListProcedure(plan, names) {
+    const procName = `list${names.pascalPlural}`;
+    const hasIncludes = plan.includeRelations.length > 0;
+    const lines = [];
+    lines.push(`  ${procName}: procedure()`);
+    lines.push(`    .input(List${names.pascalPlural}Schema)`);
+    if (plan.outputStrategy === 'output') {
+        lines.push(`    .query(async ({ input, ctx }) => {`);
+    }
+    else {
+        lines.push(`    .query(async ({ input, ctx }) => {`);
+    }
+    lines.push(`      const { page, perPage } = input;`);
+    lines.push(`      const [items, total] = await Promise.all([`);
+    lines.push(`        ctx.db.${names.camel}.findMany({`);
+    lines.push(`          skip: (page - 1) * perPage,`);
+    lines.push(`          take: perPage,`);
+    lines.push(`          orderBy: { createdAt: 'desc' },`);
+    if (hasIncludes) {
+        lines.push(generateIncludeBlock(plan.includeRelations, 10));
+    }
+    lines.push(`        }),`);
+    lines.push(`        ctx.db.${names.camel}.count(),`);
+    lines.push(`      ]);`);
+    if (plan.outputStrategy === 'resource') {
+        lines.push(`      return {`);
+        lines.push(`        items: resourceCollection(items, ${names.pascal}Schema.public),`);
+        lines.push(`        total, page, perPage,`);
+        lines.push(`      };`);
+    }
+    else {
+        lines.push(`      return { items, total, page, perPage };`);
+    }
+    lines.push(`    }),`);
+    return lines.join('\n');
+}
+function generateCreateProcedure(plan, names) {
+    const procName = `create${names.pascal}`;
+    const userFkField = plan.model.fields.find((f) => f.isUserForeignKey);
+    const lines = [];
+    lines.push(`  ${procName}: procedure()`);
+    lines.push(`    .input(Create${names.pascal}Schema)`);
+    lines.push(`    .mutation(async ({ input, ctx }) => {`);
+    if (userFkField) {
+        lines.push(`      return ctx.db.${names.camel}.create({`);
+        lines.push(`        data: { ...input, ${userFkField.name}: ctx.user.id },`);
+        lines.push(`      });`);
+    }
+    else {
+        lines.push(`      return ctx.db.${names.camel}.create({ data: input });`);
+    }
+    lines.push(`    }),`);
+    return lines.join('\n');
+}
+function generateUpdateProcedure(_plan, names) {
+    const procName = `update${names.pascal}`;
+    const lines = [];
+    lines.push(`  ${procName}: procedure()`);
+    lines.push(`    .input(z.object({ id: z.string().uuid() }).merge(Update${names.pascal}Schema))`);
+    lines.push(`    .mutation(async ({ input, ctx }) => {`);
+    lines.push(`      const { id, ...data } = input;`);
+    lines.push(`      return ctx.db.${names.camel}.update({ where: { id }, data });`);
+    lines.push(`    }),`);
+    return lines.join('\n');
+}
+function generateDeleteProcedure(plan, names) {
+    const procName = `delete${names.pascal}`;
+    const lines = [];
+    lines.push(`  ${procName}: procedure()`);
+    if (plan.model.isJoinTable && plan.model.uniqueConstraints.length > 0) {
+        // Join table: use compound unique key for delete
+        const constraintFields = plan.model.uniqueConstraints[0];
+        const compoundKeyName = constraintFields.join('_');
+        const inputFields = constraintFields.map((f) => `${f}: z.string().uuid()`).join(', ');
+        const whereFields = constraintFields.map((f) => `${f}: input.${f}`).join(', ');
+        lines.push(`    .input(z.object({ ${inputFields} }))`);
+        lines.push(`    .mutation(async ({ input, ctx }) => {`);
+        lines.push(`      await ctx.db.${names.camel}.delete({`);
+        lines.push(`        where: { ${compoundKeyName}: { ${whereFields} } },`);
+        lines.push(`      });`);
+        lines.push(`      return { success: true };`);
+        lines.push(`    }),`);
+    }
+    else {
+        lines.push(`    .input(z.object({ id: z.string().uuid() }))`);
+        lines.push(`    .mutation(async ({ input, ctx }) => {`);
+        lines.push(`      await ctx.db.${names.camel}.delete({ where: { id: input.id } });`);
+        lines.push(`      return { success: true };`);
+        lines.push(`    }),`);
+    }
+    return lines.join('\n');
+}
+// ============================================================================
+// Include Block Helper
+// ============================================================================
+function generateIncludeBlock(relations, indent) {
+    const pad = ' '.repeat(indent);
+    const lines = [];
+    lines.push(`${pad}include: {`);
+    for (const rel of relations) {
+        lines.push(`${pad}  ${rel}: true,`);
+    }
+    lines.push(`${pad}},`);
+    return lines.join('\n');
+}