@veloxts/cli 0.7.2 → 0.7.4

package/CHANGELOG.md

@@ -1,16 +1,37 @@
 # @veloxts/cli
 
+## 0.7.4
+
+### Patch Changes
+
+- feat(cli): add velox sync command for whole-schema Prisma-to-TypeScript generation
+- Updated dependencies
+  - @veloxts/auth@0.7.4
+  - @veloxts/core@0.7.4
+  - @veloxts/orm@0.7.4
+  - @veloxts/router@0.7.4
+  - @veloxts/validation@0.7.4
+
+## 0.7.3
+
+### Patch Changes
+
+- feat(cli): auto-populate Zod schemas from Prisma model fields
+- Updated dependencies
+  - @veloxts/auth@0.7.3
+  - @veloxts/core@0.7.3
+  - @veloxts/orm@0.7.3
+  - @veloxts/router@0.7.3
+  - @veloxts/validation@0.7.3
+
 ## 0.7.2
 
 ### Patch Changes
 
-- chore(auth,core,create,cli,client,orm,mcp,router,validation,web): simplify code for clarity and maintainability
+- fix(cli): replace require() with readFileSync in MCP tests
+- simplify code for clarity and maintainability
 - Updated dependencies
-  - @veloxts/auth@0.7.2
   - @veloxts/core@0.7.2
-  - @veloxts/orm@0.7.2
-  - @veloxts/router@0.7.2
-  - @veloxts/validation@0.7.2
 
 ## 0.7.1
 

package/dist/cli.js

@@ -18,6 +18,7 @@ import { createMigrateCommand } from './commands/migrate.js';
 import { createOpenApiCommand } from './commands/openapi.js';
 import { createProceduresCommand } from './commands/procedures.js';
 import { createScheduleCommand } from './commands/schedule.js';
+import { createSyncCommand } from './commands/sync.js';
 import { createTenantCommand } from './commands/tenant.js';
 import { CLI_VERSION } from './index.js';
 /**
@@ -40,6 +41,7 @@ function createCLI() {
     program.addCommand(createOpenApiCommand());
     program.addCommand(createProceduresCommand());
     program.addCommand(createScheduleCommand());
+    program.addCommand(createSyncCommand());
     program.addCommand(createTenantCommand());
     return program;
 }

package/dist/commands/sync.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Sync command - Generate Zod schemas + CRUD procedures from Prisma schema
+ *
+ * Usage:
+ *   velox sync [options]
+ *
+ * Options:
+ *   --dry-run             Preview changes without writing files
+ *   --force               Skip prompts, generate all models with defaults
+ *   --skip-registration   Skip auto-registering procedures in router
+ *
+ * Examples:
+ *   velox sync                       Interactive sync for all models
+ *   velox sync --dry-run             Preview what would be generated
+ *   velox sync --force               Generate all models with defaults
+ *   velox sync --skip-registration   Skip router registration
+ */
+import { Command } from 'commander';
+/**
+ * Create the `velox sync` command.
+ */
+export declare function createSyncCommand(): Command;

package/dist/commands/sync.js

@@ -0,0 +1,96 @@
+/**
+ * Sync command - Generate Zod schemas + CRUD procedures from Prisma schema
+ *
+ * Usage:
+ *   velox sync [options]
+ *
+ * Options:
+ *   --dry-run             Preview changes without writing files
+ *   --force               Skip prompts, generate all models with defaults
+ *   --skip-registration   Skip auto-registering procedures in router
+ *
+ * Examples:
+ *   velox sync                       Interactive sync for all models
+ *   velox sync --dry-run             Preview what would be generated
+ *   velox sync --force               Generate all models with defaults
+ *   velox sync --skip-registration   Skip router registration
+ */
+import * as p from '@clack/prompts';
+import { Command } from 'commander';
+import pc from 'picocolors';
+import { ensureVeloxProject } from '../generators/index.js';
+import { findPrismaSchema } from '../generators/utils/prisma-schema.js';
+import { executeSync } from '../sync/index.js';
+// ============================================================================
+// Command Creation
+// ============================================================================
+/**
+ * Create the `velox sync` command.
+ */
+export function createSyncCommand() {
+    const cmd = new Command('sync')
+        .description('Generate Zod schemas and CRUD procedures from Prisma schema')
+        .option('-d, --dry-run', 'Preview changes without writing files', false)
+        .option('-f, --force', 'Skip prompts and generate all models with defaults', false)
+        .option('--skip-registration', 'Skip auto-registering procedures in router', false)
+        .action(async (options) => {
+        await runSync(options);
+    });
+    return cmd;
+}
+// ============================================================================
+// Command Execution
+// ============================================================================
+/**
+ * Run the sync pipeline.
+ */
+async function runSync(options) {
+    const projectRoot = process.cwd();
+    try {
+        // Verify we're in a VeloxTS project
+        await ensureVeloxProject(projectRoot);
+        // Verify Prisma schema exists
+        const schemaPath = findPrismaSchema(projectRoot);
+        if (!schemaPath) {
+            p.log.error('Prisma schema not found. Ensure prisma/schema.prisma exists in your project.');
+            process.exit(1);
+        }
+        p.intro(pc.bgCyan(pc.black(' VeloxTS Sync ')));
+        const result = await executeSync(projectRoot, {
+            dryRun: options.dryRun,
+            force: options.force,
+            skipRegistration: options.skipRegistration,
+        });
+        // Show final summary
+        const totalCreated = result.created.length;
+        const totalOverwritten = result.overwritten.length;
+        const totalRegistered = result.registered.length;
+        const totalErrors = result.errors.length;
+        if (totalErrors > 0) {
+            p.outro(pc.yellow(`Sync completed with ${totalErrors} error${totalErrors === 1 ? '' : 's'}. ` +
+                `${totalCreated} created, ${totalOverwritten} overwritten.`));
+            process.exit(1);
+        }
+        if (totalCreated === 0 && totalOverwritten === 0) {
+            p.outro(pc.dim('Nothing to generate.'));
+        }
+        else {
+            const parts = [];
+            if (totalCreated > 0) {
+                parts.push(`${totalCreated} created`);
+            }
+            if (totalOverwritten > 0) {
+                parts.push(`${totalOverwritten} overwritten`);
+            }
+            if (totalRegistered > 0) {
+                parts.push(`${totalRegistered} registered`);
+            }
+            p.outro(pc.green(`Sync complete: ${parts.join(', ')}.`));
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        p.log.error(message);
+        process.exit(1);
+    }
+}

package/dist/generators/fields/types.d.ts

@@ -88,6 +88,13 @@ export declare function validateEnumName(name: string): string | undefined;
  * Validate enum values format (UPPER_CASE)
  */
 export declare function validateEnumValues(values: string[]): string | undefined;
+/**
+ * Map a Prisma schema type string to a FieldType
+ *
+ * Used when reading fields from an existing Prisma model to convert them
+ * into FieldDefinition objects for code generation.
+ */
+export declare function prismaTypeToFieldType(prismaType: string): FieldType;
 /**
  * Parse comma-separated enum values
  */

package/dist/generators/fields/types.js

@@ -138,6 +138,35 @@ export function validateEnumValues(values) {
     }
     return undefined;
 }
+// ============================================================================
+// Prisma Type Mapping
+// ============================================================================
+/**
+ * Map a Prisma schema type string to a FieldType
+ *
+ * Used when reading fields from an existing Prisma model to convert them
+ * into FieldDefinition objects for code generation.
+ */
+export function prismaTypeToFieldType(prismaType) {
+    switch (prismaType) {
+        case 'String':
+            return 'string';
+        case 'Int':
+            return 'int';
+        case 'Float':
+        case 'Decimal':
+        case 'BigInt':
+            return 'float';
+        case 'Boolean':
+            return 'boolean';
+        case 'DateTime':
+            return 'datetime';
+        case 'Json':
+            return 'json';
+        default:
+            return 'string';
+    }
+}
 /**
  * Parse comma-separated enum values
  */

package/dist/generators/generators/namespace.js

@@ -14,7 +14,7 @@
 import { BaseGenerator } from '../base.js';
 import { getNamespaceInstructions, getNamespaceProcedurePath, getNamespaceSchemaPath, getNamespaceTestPath, namespaceSchemaTemplate, namespaceTemplate, namespaceTestTemplate, } from '../templates/namespace.js';
 import { deriveEntityNames } from '../utils/naming.js';
-import { analyzePrismaSchema, findPrismaSchema, getModelRelations, hasModel, } from '../utils/prisma-schema.js';
+import { analyzePrismaSchema, findPrismaSchema, getModelFields, getModelRelations, hasModel, } from '../utils/prisma-schema.js';
 import { detectRouterPattern, isProcedureRegistered, registerProcedures, } from '../utils/router-integration.js';
 // ============================================================================
 // Generator Implementation
@@ -113,10 +113,15 @@ Examples:
                             hasMany: [...modelRelations.hasMany],
                         };
                     }
+                    // Extract scalar fields for Zod schema generation
+                    const scalarFields = getModelFields(schemaAnalysis, entity.pascal);
+                    if (scalarFields.length > 0) {
+                        enrichedOptions.fields = scalarFields;
+                    }
                 }
             }
             catch {
-                // Schema parsing failed — proceed without relations
+                // Schema parsing failed — proceed without relations or fields
             }
         }
         const enrichedConfig = { ...config, options: enrichedOptions };

package/dist/generators/templates/namespace.d.ts

@@ -5,6 +5,7 @@
  * Unlike the procedure generator, this creates a minimal scaffold ready for
  * custom procedures rather than pre-defined CRUD operations.
  */
+import type { FieldDefinition } from '../fields/types.js';
 import type { TemplateContext, TemplateFunction } from '../types.js';
 /**
  * Relation info for code generation (shared with resource template)
@@ -24,6 +25,8 @@ export interface NamespaceOptions {
     withTests: boolean;
     /** Detected relations from Prisma schema */
     relations?: RelationInfo;
+    /** Scalar fields extracted from Prisma model */
+    fields?: FieldDefinition[];
 }
 /**
  * Generate namespace procedure file

package/dist/generators/templates/namespace.js

@@ -5,6 +5,8 @@
  * Unlike the procedure generator, this creates a minimal scaffold ready for
  * custom procedures rather than pre-defined CRUD operations.
  */
+import { FIELD_TYPES } from '../fields/types.js';
+import { fieldToZod } from '../templates/resource.js';
 // ============================================================================
 // Relation Helpers
 // ============================================================================
@@ -170,7 +172,89 @@ export const ${entity.camel}Procedures = procedures('${entity.plural}', {
  * Generate schema file for the namespace
  */
 export function namespaceSchemaTemplate(ctx) {
-    const { entity } = ctx;
+    const { entity, options } = ctx;
+    const fields = options.fields;
+    if (fields && fields.length > 0) {
+        return generateSchemaWithFields(entity, fields);
+    }
+    return generateSchemaPlaceholder(entity);
+}
+/**
+ * Generate schema with actual fields from Prisma model
+ */
+function generateSchemaWithFields(entity, fields) {
+    // Base schema: all fields
+    const baseFields = fields.map(fieldToZod).join('\n');
+    // Create input: non-auto-generated fields (those without @default or @updatedAt)
+    const createFields = fields.filter((f) => !f.attributes.hasDefault);
+    const createFieldLines = createFields.map((f) => {
+        // In create input, optional fields use .optional() instead of .nullable()
+        return fieldToZodForInput(f);
+    });
+    const createContent = createFieldLines.join('\n');
+    return `/**
+ * ${entity.pascal} Schemas
+ *
+ * Zod validation schemas for ${entity.humanReadable} entities.
+ */
+
+import { z } from 'zod';
+
+// ============================================================================
+// Base Schema
+// ============================================================================
+
+/**
+ * ${entity.pascal} entity schema
+ */
+export const ${entity.pascal}Schema = z.object({
+  id: z.string().uuid(),
+${baseFields}
+  createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date(),
+});
+
+export type ${entity.pascal} = z.infer<typeof ${entity.pascal}Schema>;
+
+// ============================================================================
+// Input Schemas
+// ============================================================================
+
+/**
+ * Create ${entity.pascal} input
+ */
+export const Create${entity.pascal}Input = z.object({
+${createContent}
+});
+
+export type Create${entity.pascal}InputType = z.infer<typeof Create${entity.pascal}Input>;
+
+/**
+ * Update ${entity.pascal} input
+ */
+export const Update${entity.pascal}Input = z.object({
+${createContent}
+}).partial();
+
+export type Update${entity.pascal}InputType = z.infer<typeof Update${entity.pascal}Input>;
+`;
+}
+/**
+ * Convert a field to Zod for input schemas (optional → .optional() instead of .nullable())
+ */
+function fieldToZodForInput(field) {
+    // Create a copy with optional mapped to .optional() suffix
+    const typeInfo = FIELD_TYPES.find((t) => t.type === field.type);
+    let zodType = typeInfo?.zodSchema ?? 'z.string()';
+    if (field.attributes.optional) {
+        zodType += '.optional()';
+    }
+    return `  ${field.name}: ${zodType},`;
+}
+/**
+ * Generate schema with TODO placeholders (no Prisma model found)
+ */
+function generateSchemaPlaceholder(entity) {
     return `/**
  * ${entity.pascal} Schemas
  *

package/dist/generators/utils/prisma-schema.d.ts

@@ -4,6 +4,7 @@
  * Parses Prisma schema files to find models/enums and enables safe injection
  * of new definitions without breaking existing code.
  */
+import type { FieldDefinition } from '../fields/types.js';
 /**
  * Parsed information about a single field in a Prisma model
  */
@@ -18,6 +19,10 @@ export interface PrismaFieldInfo {
     readonly isArray: boolean;
     /** The related model name, if this is a relation field */
     readonly relatedModel: string | undefined;
+    /** Whether this field has a `?` modifier (nullable/optional) */
+    readonly isOptional: boolean;
+    /** Whether this field has `@default(...)` or `@updatedAt` */
+    readonly hasDefault: boolean;
 }
 /**
  * Detailed information about a Prisma model including its fields
@@ -129,6 +134,19 @@ export declare function injectIntoSchema(analysis: PrismaSchemaAnalysis, models:
  * Throws if any model or enum already exists (prevents accidental overwrites)
  */
 export declare function validateNoConflicts(analysis: PrismaSchemaAnalysis, models: PrismaModelDefinition[], enums?: PrismaEnumDefinition[]): void;
+/**
+ * Convert a PrismaFieldInfo to a FieldDefinition for code generation
+ *
+ * Returns null for fields that should be skipped (relations, reserved names).
+ */
+export declare function prismaFieldToFieldDefinition(field: PrismaFieldInfo): FieldDefinition | null;
+/**
+ * Get scalar, non-auto-generated fields from a Prisma model as FieldDefinitions
+ *
+ * Filters out relation fields, reserved fields (id, createdAt, updatedAt, deletedAt),
+ * and fields with @id annotation.
+ */
+export declare function getModelFields(analysis: PrismaSchemaAnalysis, modelName: string): FieldDefinition[];
 /**
  * Generate a minimal Prisma model string
  */

package/dist/generators/utils/prisma-schema.js

@@ -5,6 +5,7 @@
  * of new definitions without breaking existing code.
  */
 import { existsSync, readFileSync } from 'node:fs';
+import { prismaTypeToFieldType, RESERVED_FIELD_NAMES } from '../fields/types.js';
 import { GeneratorError, GeneratorErrorCode } from '../types.js';
 // ============================================================================
 // Schema Parsing
@@ -156,13 +157,15 @@ function parseModelFields(body, modelNames) {
             continue;
         }
         // Parse field: name Type[?][] [@annotations...]
-        // Match: fieldName  TypeName  optional modifiers
-        const fieldMatch = trimmed.match(/^(\w+)\s+(\w+)(\[\])?\??/);
+        // Match: fieldName  TypeName  optional array and optional modifiers
+        const fieldMatch = trimmed.match(/^(\w+)\s+(\w+)(\[\])?(\?)?/);
         if (!fieldMatch)
             continue;
         const name = fieldMatch[1];
         const baseType = fieldMatch[2];
         const isArray = fieldMatch[3] === '[]';
+        const isOptional = fieldMatch[4] === '?';
+        const hasDefault = /@default\(/.test(trimmed) || /@updatedAt/.test(trimmed);
         // Check if this is a relation field (type matches a known model)
         const isRelation = modelNames.has(baseType);
         if (!isRelation) {
@@ -172,6 +175,8 @@ function parseModelFields(body, modelNames) {
                 isRelation: false,
                 isArray: false,
                 relatedModel: undefined,
+                isOptional,
+                hasDefault,
             });
             continue;
         }
@@ -188,6 +193,8 @@ function parseModelFields(body, modelNames) {
             isRelation: true,
             isArray,
             relatedModel: baseType,
+            isOptional,
+            hasDefault,
         });
     }
     return fields;
@@ -311,6 +318,50 @@ export function validateNoConflicts(analysis, models, enums = []) {
     }
 }
 // ============================================================================
+// Field Conversion
+// ============================================================================
+/**
+ * Convert a PrismaFieldInfo to a FieldDefinition for code generation
+ *
+ * Returns null for fields that should be skipped (relations, reserved names).
+ */
+export function prismaFieldToFieldDefinition(field) {
+    // Skip relation fields
+    if (field.isRelation)
+        return null;
+    // Skip reserved fields (id, createdAt, updatedAt, deletedAt)
+    if (RESERVED_FIELD_NAMES.includes(field.name))
+        return null;
+    return {
+        name: field.name,
+        type: prismaTypeToFieldType(field.type),
+        attributes: {
+            optional: field.isOptional,
+            unique: false, // Not tracked in PrismaFieldInfo
+            hasDefault: field.hasDefault,
+        },
+    };
+}
+/**
+ * Get scalar, non-auto-generated fields from a Prisma model as FieldDefinitions
+ *
+ * Filters out relation fields, reserved fields (id, createdAt, updatedAt, deletedAt),
+ * and fields with @id annotation.
+ */
+export function getModelFields(analysis, modelName) {
+    const modelInfo = analysis.modelDetails.get(modelName);
+    if (!modelInfo)
+        return [];
+    const fields = [];
+    for (const field of modelInfo.fields) {
+        const converted = prismaFieldToFieldDefinition(field);
+        if (converted) {
+            fields.push(converted);
+        }
+    }
+    return fields;
+}
+// ============================================================================
 // Helpers
 // ============================================================================
 /**

package/dist/sync/analyzer.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Sync Analyzer
+ *
+ * Reads a Prisma schema and produces rich `SyncModelInfo[]` metadata
+ * for every model. This is stage 1 of the `velox sync` pipeline.
+ *
+ * The analyzer re-parses the raw schema text (rather than relying solely
+ * on the existing `analyzePrismaSchema` helper) because the helper skips
+ * relation fields that carry `@relation(fields: [...])` -- exactly the
+ * ones we need to classify belongsTo relations and detect foreign keys.
+ */
+import type { SyncModelInfo } from './types.js';
+/**
+ * Analyze a Prisma schema and produce sync metadata for every model.
+ *
+ * @param projectRoot - Absolute path to the project root directory
+ * @returns Array of `SyncModelInfo` objects, one per Prisma model
+ * @throws If no Prisma schema can be found
+ */
+export declare function analyzeSchema(projectRoot: string): SyncModelInfo[];