@veloxts/cli 0.6.64 → 0.6.66

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @veloxts/cli
 
+## 0.6.66
+
+### Patch Changes
+
+- docs(skills): recommend namespace generator for AI agents
+- Updated dependencies
+  - @veloxts/auth@0.6.66
+  - @veloxts/core@0.6.66
+  - @veloxts/orm@0.6.66
+  - @veloxts/router@0.6.66
+  - @veloxts/validation@0.6.66
+
+## 0.6.65
+
+### Patch Changes
+
+- improve ai integration and simplify api router definition
+- Updated dependencies
+  - @veloxts/auth@0.6.65
+  - @veloxts/core@0.6.65
+  - @veloxts/orm@0.6.65
+  - @veloxts/router@0.6.65
+  - @veloxts/validation@0.6.65
+
 ## 0.6.64
 
 ### Patch Changes

package/dist/generators/generators/index.d.ts

@@ -14,6 +14,7 @@ export { createMailGenerator, MailGenerator } from './mail.js';
 export { createMiddlewareGenerator, MiddlewareGenerator } from './middleware.js';
 export { createMigrationGenerator, MigrationGenerator } from './migration.js';
 export { createModelGenerator, ModelGenerator } from './model.js';
+export { createNamespaceGenerator, NamespaceGenerator } from './namespace.js';
 export { createPageGenerator, PageGenerator } from './page.js';
 export { createPolicyGenerator, PolicyGenerator } from './policy.js';
 export { createProcedureGenerator, ProcedureGenerator } from './procedure.js';

package/dist/generators/generators/index.js

@@ -15,6 +15,7 @@ import { createMailGenerator } from './mail.js';
 import { createMiddlewareGenerator } from './middleware.js';
 import { createMigrationGenerator } from './migration.js';
 import { createModelGenerator } from './model.js';
+import { createNamespaceGenerator } from './namespace.js';
 import { createPageGenerator } from './page.js';
 import { createPolicyGenerator } from './policy.js';
 import { createProcedureGenerator } from './procedure.js';
@@ -39,6 +40,7 @@ export { createMailGenerator, MailGenerator } from './mail.js';
 export { createMiddlewareGenerator, MiddlewareGenerator } from './middleware.js';
 export { createMigrationGenerator, MigrationGenerator } from './migration.js';
 export { createModelGenerator, ModelGenerator } from './model.js';
+export { createNamespaceGenerator, NamespaceGenerator } from './namespace.js';
 export { createPageGenerator, PageGenerator } from './page.js';
 export { createPolicyGenerator, PolicyGenerator } from './policy.js';
 export { createProcedureGenerator, ProcedureGenerator } from './procedure.js';
@@ -61,6 +63,8 @@ export function registerBuiltinGenerators() {
     registerGenerator(createProcedureGenerator());
     // Register model generator
     registerGenerator(createModelGenerator());
+    // Register namespace generator
+    registerGenerator(createNamespaceGenerator());
     // Register migration generator
     registerGenerator(createMigrationGenerator());
     // Register schema generator

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

@@ -0,0 +1,39 @@
+/**
+ * Namespace Generator
+ *
+ * Scaffolds a complete procedure namespace with schema file.
+ *
+ * Usage:
+ *   velox make namespace <name> [options]
+ *   velox m ns <name> [options]
+ *
+ * Examples:
+ *   velox make namespace products           # Empty namespace with schema
+ *   velox make namespace orders --example   # With example CRUD procedures
+ */
+import { BaseGenerator } from '../base.js';
+import { type NamespaceOptions } from '../templates/namespace.js';
+import type { GeneratorConfig, GeneratorMetadata, GeneratorOption, GeneratorOutput } from '../types.js';
+/**
+ * Namespace generator - creates procedure namespace with schema
+ */
+export declare class NamespaceGenerator extends BaseGenerator<NamespaceOptions> {
+    readonly metadata: GeneratorMetadata;
+    readonly options: ReadonlyArray<GeneratorOption>;
+    /**
+     * Validate and transform raw options
+     */
+    validateOptions(raw: Record<string, unknown>): NamespaceOptions;
+    /**
+     * Generate namespace files
+     */
+    generate(config: GeneratorConfig<NamespaceOptions>): Promise<GeneratorOutput>;
+    /**
+     * Build post-instructions based on registration result
+     */
+    private buildPostInstructions;
+}
+/**
+ * Create a new namespace generator instance
+ */
+export declare function createNamespaceGenerator(): NamespaceGenerator;

package/dist/generators/generators/namespace.js

@@ -0,0 +1,202 @@
+/**
+ * Namespace Generator
+ *
+ * Scaffolds a complete procedure namespace with schema file.
+ *
+ * Usage:
+ *   velox make namespace <name> [options]
+ *   velox m ns <name> [options]
+ *
+ * Examples:
+ *   velox make namespace products           # Empty namespace with schema
+ *   velox make namespace orders --example   # With example CRUD procedures
+ */
+import { BaseGenerator } from '../base.js';
+import { getNamespaceInstructions, getNamespaceProcedurePath, getNamespaceSchemaPath, getNamespaceTestPath, namespaceSchemaTemplate, namespaceTemplate, namespaceTestTemplate, } from '../templates/namespace.js';
+import { detectRouterPattern, isProcedureRegistered, registerProcedures, } from '../utils/router-integration.js';
+// ============================================================================
+// Generator Implementation
+// ============================================================================
+/**
+ * Namespace generator - creates procedure namespace with schema
+ */
+export class NamespaceGenerator extends BaseGenerator {
+    metadata = {
+        name: 'namespace',
+        description: 'Generate procedure namespace + schema (for existing models or external APIs)',
+        longDescription: `
+Scaffold a procedure namespace with a separate Zod schema file.
+
+Use this when you already have a Prisma model or are working with external data.
+For new database entities, use "velox make resource" instead (recommended).
+
+Creates:
+  • Schema file (src/schemas/{kebab}.ts)
+  • Procedure file (src/procedures/{plural}.ts)
+  • Test file (src/procedures/__tests__/{plural}.test.ts)
+  • Auto-registers in router.ts
+
+When to use:
+  ✓ You have an EXISTING Prisma model and need procedures for it
+  ✓ Calling an external API (no database model needed)
+  ✓ You want separate schema files (cleaner than inline)
+  ✓ Need procedure collection without Prisma injection
+
+When NOT to use:
+  • Creating a new database entity → use "resource" instead (recommended)
+  • Adding a single procedure → use "procedure" instead
+
+Comparison:
+  • "resource" = Prisma model + schema + procedures + tests (RECOMMENDED)
+  • "namespace" = schema + procedures (no Prisma injection)
+  • "procedure" = procedures only (inline schemas)
+
+Examples:
+  velox make namespace products           # Empty namespace for existing model
+  velox make namespace orders --example   # With example CRUD procedures
+  velox m ns external-api -e              # For external API integration
+`,
+        aliases: ['ns'],
+        category: 'resource',
+    };
+    options = [
+        {
+            name: 'example',
+            short: 'e',
+            description: 'Include example CRUD procedures',
+            type: 'boolean',
+            default: false,
+        },
+        {
+            name: 'with-tests',
+            short: 't',
+            description: 'Generate test file (default: true)',
+            type: 'boolean',
+            default: true,
+        },
+        {
+            name: 'skip-registration',
+            short: 'S',
+            description: 'Skip auto-registering the procedure in router.ts',
+            type: 'boolean',
+            default: false,
+        },
+    ];
+    /**
+     * Validate and transform raw options
+     */
+    validateOptions(raw) {
+        return {
+            withExample: Boolean(raw.example ?? raw.withExample ?? false),
+            withTests: raw['with-tests'] !== false && raw.withTests !== false,
+            skipRegistration: Boolean(raw['skip-registration'] ?? raw.skipRegistration ?? false),
+        };
+    }
+    /**
+     * Generate namespace files
+     */
+    async generate(config) {
+        const context = this.createContext(config);
+        const { entity } = context;
+        const { options } = config;
+        // Collect files to generate
+        const files = [];
+        // Generate schema file
+        const schemaContent = namespaceSchemaTemplate(context);
+        files.push({
+            path: getNamespaceSchemaPath(entity.kebab),
+            content: schemaContent,
+        });
+        // Generate procedure file
+        const procedureContent = namespaceTemplate(context);
+        files.push({
+            path: getNamespaceProcedurePath(entity.plural),
+            content: procedureContent,
+        });
+        // Generate test file (default: true)
+        if (options.withTests) {
+            const testContent = namespaceTestTemplate(context);
+            files.push({
+                path: getNamespaceTestPath(entity.plural),
+                content: testContent,
+            });
+        }
+        // Try auto-registration if not skipped
+        let registrationResult = null;
+        if (!options.skipRegistration && !config.dryRun) {
+            const procedureVar = `${entity.camel}Procedures`;
+            // Check if already registered
+            if (!isProcedureRegistered(config.cwd, procedureVar)) {
+                // Detect router pattern
+                const pattern = detectRouterPattern(config.cwd);
+                if (pattern.type !== 'unknown') {
+                    // Perform registration
+                    registrationResult = registerProcedures(config.cwd, entity.kebab, procedureVar, false // not a dry run
+                    );
+                }
+            }
+        }
+        // Generate post-creation instructions
+        const postInstructions = this.buildPostInstructions(entity, options, registrationResult);
+        return {
+            files,
+            postInstructions,
+        };
+    }
+    /**
+     * Build post-instructions based on registration result
+     */
+    buildPostInstructions(entity, options, registrationResult) {
+        const procedureVar = `${entity.camel}Procedures`;
+        // If registration was successful
+        if (registrationResult?.success) {
+            const modifiedFiles = registrationResult.modifiedFiles.map((f) => `    - ${f}`).join('\n');
+            const testFileInfo = options.withTests
+                ? `
+    - src/procedures/__tests__/${entity.plural}.test.ts`
+                : '';
+            let instructions = `
+  ✓ Namespace ${procedureVar} auto-registered!
+
+  Created files:
+    - src/schemas/${entity.kebab}.ts
+    - src/procedures/${entity.plural}.ts${testFileInfo}
+
+  Modified files:
+${modifiedFiles}`;
+            const nextStep = options.withExample
+                ? 'Customize the example procedures'
+                : `Add procedures to src/procedures/${entity.plural}.ts`;
+            const testStep = options.withTests ? '\n  4. Run tests: pnpm test' : '';
+            instructions += `
+
+  Next steps:
+  1. Add fields to your schema in src/schemas/${entity.kebab}.ts
+  2. Add the ${entity.pascal} model to your Prisma schema
+  3. ${nextStep}${testStep}`;
+            return instructions;
+        }
+        // If registration was skipped
+        if (options.skipRegistration) {
+            return getNamespaceInstructions(entity.plural, entity.pascal, entity.kebab);
+        }
+        // If registration failed
+        if (registrationResult?.error) {
+            return `
+  ⚠ Auto-registration failed: ${registrationResult.error}
+
+${getNamespaceInstructions(entity.plural, entity.pascal, entity.kebab)}`;
+        }
+        // Default: show manual instructions
+        return getNamespaceInstructions(entity.plural, entity.pascal, entity.kebab);
+    }
+}
+// ============================================================================
+// Export
+// ============================================================================
+/**
+ * Create a new namespace generator instance
+ */
+export function createNamespaceGenerator() {
+    return new NamespaceGenerator();
+}

package/dist/generators/generators/procedure.js

@@ -24,17 +24,35 @@ import { detectRouterPattern, isProcedureRegistered, registerProcedures, } from
 export class ProcedureGenerator extends BaseGenerator {
     metadata = {
         name: 'procedure',
-        description: 'Generate a procedure file for API endpoints',
+        description: 'Generate a procedure file (for single or additional procedures)',
         longDescription: `
-Scaffold a VeloxTS procedure file that defines API endpoints.
+Scaffold a standalone procedure file with inline schemas.
 
-By default, scaffolds a simple procedure with just a get operation.
-Use --crud to scaffold full CRUD operations (get, list, create, update, patch, delete).
+Use this for adding individual procedures or extending existing namespaces.
+For new database entities, use "velox make resource" instead (recommended).
+
+Creates:
+  • Procedure file (src/procedures/{plural}.ts) with inline Zod schemas
+  • Auto-registers in router.ts
+
+When to use:
+  ✓ Adding a single procedure to your API
+  ✓ Quick prototyping (inline schemas, no separate files)
+  ✓ Extending an existing namespace with additional procedures
+
+When NOT to use:
+  • Creating a new database entity → use "resource" instead (recommended)
+  • Want separate schema files → use "namespace" instead
+
+Comparison:
+  • "resource" = Prisma model + schema + procedures + tests (RECOMMENDED)
+  • "namespace" = schema + procedures (separate files)
+  • "procedure" = procedures only (inline schemas, self-contained)
 
 Examples:
-  velox make procedure users           # Simple get procedure
-  velox make procedure posts --crud    # Full CRUD procedures
-  velox m p comments --crud --paginated    # CRUD with pagination
+  velox make procedure health            # Single health check procedure
+  velox make procedure users --crud      # CRUD with inline schemas
+  velox m p analytics                    # Quick procedure for analytics
 `,
         aliases: ['p', 'proc'],
         category: 'resource',

package/dist/generators/generators/resource.js

@@ -27,7 +27,37 @@ import { createSnapshot, rollback, saveOriginal, trackCreated, } from '../utils/
 // ============================================================================
 const metadata = {
     name: 'resource',
-    description: 'Generate complete resource (model, schema, procedures, tests)',
+    description: 'Generate complete resource (model, schema, procedures, tests) [RECOMMENDED]',
+    longDescription: `
+RECOMMENDED: The resource generator is the preferred way to create new entities.
+
+This is VeloxTS's equivalent to Laravel's "php artisan make:model -a" - it scaffolds
+everything you need for a new entity in one command.
+
+Creates:
+  • Prisma model (auto-injected into schema.prisma)
+  • Zod validation schemas (src/schemas/{name}.schema.ts)
+  • CRUD procedures (src/procedures/{name}.ts)
+  • Test file (src/procedures/__tests__/{name}.test.ts)
+  • Auto-registers in router.ts
+  • Optional: runs Prisma migration
+
+When to use:
+  ✓ Creating a new database entity (users, posts, products, etc.)
+  ✓ You want the full VeloxTS stack with tests
+  ✓ Default choice for most scenarios
+
+When NOT to use:
+  • You have an existing Prisma model → use "namespace" instead
+  • You're calling an external API (no database) → use "namespace" instead
+  • Adding a single procedure to existing namespace → use "procedure" instead
+
+Examples:
+  velox make resource Post                     # Full stack for Post entity
+  velox make resource Comment -i               # Interactive field definition
+  velox make resource Order --soft-delete      # With soft delete support
+  velox m r Product --auto-migrate             # Auto-run migration
+`,
     category: 'resource',
     aliases: ['r', 'res'],
 };

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

@@ -0,0 +1,44 @@
+/**
+ * Namespace Template
+ *
+ * Generates a procedure namespace (collection) with corresponding schema file.
+ * Unlike the procedure generator, this creates a minimal scaffold ready for
+ * custom procedures rather than pre-defined CRUD operations.
+ */
+import type { TemplateContext, TemplateFunction } from '../types.js';
+export interface NamespaceOptions {
+    /** Skip auto-registering in router.ts */
+    skipRegistration: boolean;
+    /** Include example procedure */
+    withExample: boolean;
+    /** Generate test file */
+    withTests: boolean;
+}
+/**
+ * Generate namespace procedure file
+ */
+export declare const namespaceTemplate: TemplateFunction<NamespaceOptions>;
+/**
+ * Generate schema file for the namespace
+ */
+export declare function namespaceSchemaTemplate(ctx: TemplateContext<NamespaceOptions>): string;
+/**
+ * Generate test file for the namespace procedures
+ */
+export declare function namespaceTestTemplate(ctx: TemplateContext<NamespaceOptions>): string;
+/**
+ * Get the file path for the procedure file
+ */
+export declare function getNamespaceProcedurePath(entityPlural: string): string;
+/**
+ * Get the file path for the test file
+ */
+export declare function getNamespaceTestPath(entityPlural: string): string;
+/**
+ * Get the file path for the schema file
+ */
+export declare function getNamespaceSchemaPath(entityKebab: string): string;
+/**
+ * Generate post-generation instructions
+ */
+export declare function getNamespaceInstructions(entityPlural: string, entityPascal: string, entityKebab: string): string;

package/dist/generators/templates/namespace.js

@@ -0,0 +1,444 @@
+/**
+ * Namespace Template
+ *
+ * Generates a procedure namespace (collection) with corresponding schema file.
+ * Unlike the procedure generator, this creates a minimal scaffold ready for
+ * custom procedures rather than pre-defined CRUD operations.
+ */
+// ============================================================================
+// Template Functions
+// ============================================================================
+/**
+ * Generate namespace procedure file
+ */
+export const namespaceTemplate = (ctx) => {
+    const { entity, options } = ctx;
+    if (options.withExample) {
+        return generateWithExample(ctx);
+    }
+    return `/**
+ * ${entity.pascal} Procedures
+ *
+ * Namespace for ${entity.humanReadable}-related API endpoints.
+ */
+
+import { procedure, procedures, z } from '@veloxts/velox';
+import {
+  ${entity.pascal}Schema,
+  Create${entity.pascal}Input,
+  Update${entity.pascal}Input,
+} from '../schemas/${entity.kebab}.js';
+
+// ============================================================================
+// Procedures
+// ============================================================================
+
+export const ${entity.camel}Procedures = procedures('${entity.plural}', {
+  // Add your procedures here
+  //
+  // Examples:
+  //
+  // get${entity.pascal}: procedure()
+  //   .input(z.object({ id: z.string().uuid() }))
+  //   .output(${entity.pascal}Schema.nullable())
+  //   .query(async ({ input, ctx }) => {
+  //     return ctx.db.${entity.camel}.findUnique({ where: { id: input.id } });
+  //   }),
+  //
+  // list${entity.pascalPlural}: procedure()
+  //   .output(z.array(${entity.pascal}Schema))
+  //   .query(async ({ ctx }) => {
+  //     return ctx.db.${entity.camel}.findMany();
+  //   }),
+  //
+  // create${entity.pascal}: procedure()
+  //   .input(Create${entity.pascal}Input)
+  //   .output(${entity.pascal}Schema)
+  //   .mutation(async ({ input, ctx }) => {
+  //     return ctx.db.${entity.camel}.create({ data: input });
+  //   }),
+});
+`;
+};
+/**
+ * Generate namespace with example procedure
+ */
+function generateWithExample(ctx) {
+    const { entity } = ctx;
+    return `/**
+ * ${entity.pascal} Procedures
+ *
+ * Namespace for ${entity.humanReadable}-related API endpoints.
+ */
+
+import { procedure, procedures, z } from '@veloxts/velox';
+import {
+  ${entity.pascal}Schema,
+  Create${entity.pascal}Input,
+  Update${entity.pascal}Input,
+} from '../schemas/${entity.kebab}.js';
+
+// ============================================================================
+// Procedures
+// ============================================================================
+
+export const ${entity.camel}Procedures = procedures('${entity.plural}', {
+  /**
+   * Get a single ${entity.humanReadable} by ID
+   * GET /${entity.plural}/:id
+   */
+  get${entity.pascal}: procedure()
+    .input(z.object({ id: z.string().uuid() }))
+    .output(${entity.pascal}Schema.nullable())
+    .query(async ({ input, ctx }) => {
+      return ctx.db.${entity.camel}.findUnique({
+        where: { id: input.id },
+      });
+    }),
+
+  /**
+   * List all ${entity.humanReadablePlural}
+   * GET /${entity.plural}
+   */
+  list${entity.pascalPlural}: procedure()
+    .output(z.array(${entity.pascal}Schema))
+    .query(async ({ ctx }) => {
+      return ctx.db.${entity.camel}.findMany();
+    }),
+
+  /**
+   * Create a new ${entity.humanReadable}
+   * POST /${entity.plural}
+   */
+  create${entity.pascal}: procedure()
+    .input(Create${entity.pascal}Input)
+    .output(${entity.pascal}Schema)
+    .mutation(async ({ input, ctx }) => {
+      return ctx.db.${entity.camel}.create({
+        data: input,
+      });
+    }),
+
+  /**
+   * Update an existing ${entity.humanReadable}
+   * PUT /${entity.plural}/:id
+   */
+  update${entity.pascal}: procedure()
+    .input(z.object({ id: z.string().uuid() }).merge(Update${entity.pascal}Input))
+    .output(${entity.pascal}Schema)
+    .mutation(async ({ input, ctx }) => {
+      const { id, ...data } = input;
+      return ctx.db.${entity.camel}.update({
+        where: { id },
+        data,
+      });
+    }),
+
+  /**
+   * Delete a ${entity.humanReadable}
+   * DELETE /${entity.plural}/:id
+   */
+  delete${entity.pascal}: procedure()
+    .input(z.object({ id: z.string().uuid() }))
+    .output(z.object({ success: z.boolean() }))
+    .mutation(async ({ input, ctx }) => {
+      await ctx.db.${entity.camel}.delete({
+        where: { id: input.id },
+      });
+      return { success: true };
+    }),
+});
+`;
+}
+/**
+ * Generate schema file for the namespace
+ */
+export function namespaceSchemaTemplate(ctx) {
+    const { entity } = ctx;
+    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(),
+  // TODO: Add ${entity.humanReadable} fields
+  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({
+  // TODO: Add required fields for creating a ${entity.humanReadable}
+});
+
+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({
+  // TODO: Add fields for updating a ${entity.humanReadable}
+}).partial();
+
+export type Update${entity.pascal}InputType = z.infer<typeof Update${entity.pascal}Input>;
+`;
+}
+// ============================================================================
+// Test Template
+// ============================================================================
+/**
+ * Generate test file for the namespace procedures
+ */
+export function namespaceTestTemplate(ctx) {
+    const { entity, options } = ctx;
+    if (options.withExample) {
+        return generateTestWithCrud(entity);
+    }
+    return `/**
+ * ${entity.pascal} Procedures - Tests
+ *
+ * Unit tests for ${entity.humanReadable} API procedures.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+// import { ${entity.camel}Procedures } from '../${entity.plural}.js';
+
+// ============================================================================
+// Test Setup
+// ============================================================================
+
+describe('${entity.pascal} Procedures', () => {
+  const mockCtx = {
+    db: {
+      ${entity.camel}: {
+        findUnique: vi.fn(),
+        findMany: vi.fn(),
+        create: vi.fn(),
+        update: vi.fn(),
+        delete: vi.fn(),
+      },
+    },
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  // Add your tests here
+  // Example:
+  //
+  // describe('get${entity.pascal}', () => {
+  //   it('should return a ${entity.humanReadable} by id', async () => {
+  //     const mock${entity.pascal} = { id: 'test-uuid' };
+  //     mockCtx.db.${entity.camel}.findUnique.mockResolvedValue(mock${entity.pascal});
+  //
+  //     // TODO: Implement test
+  //   });
+  // });
+
+  it('should have mock context ready', () => {
+    expect(mockCtx.db.${entity.camel}).toBeDefined();
+  });
+});
+`;
+}
+/**
+ * Generate test file with CRUD tests for --example flag
+ */
+function generateTestWithCrud(entity) {
+    return `/**
+ * ${entity.pascal} Procedures - Tests
+ *
+ * Unit tests for ${entity.humanReadable} API procedures.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+// import { ${entity.camel}Procedures } from '../${entity.plural}.js';
+
+// ============================================================================
+// Test Setup
+// ============================================================================
+
+describe('${entity.pascal} Procedures', () => {
+  const mockCtx = {
+    db: {
+      ${entity.camel}: {
+        findUnique: vi.fn(),
+        findMany: vi.fn(),
+        count: vi.fn(),
+        create: vi.fn(),
+        update: vi.fn(),
+        delete: vi.fn(),
+      },
+    },
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  // ============================================================================
+  // Query Tests
+  // ============================================================================
+
+  describe('get${entity.pascal}', () => {
+    it('should return a ${entity.humanReadable} by id', async () => {
+      const mock${entity.pascal} = {
+        id: 'test-uuid',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      };
+      mockCtx.db.${entity.camel}.findUnique.mockResolvedValue(mock${entity.pascal});
+
+      // TODO: Call procedure and assert
+      // const result = await ${entity.camel}Procedures.procedures.get${entity.pascal}.handler({
+      //   input: { id: 'test-uuid' },
+      //   ctx: mockCtx,
+      // });
+      // expect(result).toEqual(mock${entity.pascal});
+      expect(mockCtx.db.${entity.camel}.findUnique).toBeDefined();
+    });
+
+    it('should return null for non-existent ${entity.humanReadable}', async () => {
+      mockCtx.db.${entity.camel}.findUnique.mockResolvedValue(null);
+
+      // TODO: Call procedure and assert
+      expect(mockCtx.db.${entity.camel}.findUnique).toBeDefined();
+    });
+  });
+
+  describe('list${entity.pascalPlural}', () => {
+    it('should return all ${entity.humanReadablePlural}', async () => {
+      const mock${entity.pascalPlural} = [
+        { id: 'uuid-1', createdAt: new Date(), updatedAt: new Date() },
+        { id: 'uuid-2', createdAt: new Date(), updatedAt: new Date() },
+      ];
+      mockCtx.db.${entity.camel}.findMany.mockResolvedValue(mock${entity.pascalPlural});
+
+      // TODO: Call procedure and assert
+      expect(mockCtx.db.${entity.camel}.findMany).toBeDefined();
+    });
+  });
+
+  // ============================================================================
+  // Mutation Tests
+  // ============================================================================
+
+  describe('create${entity.pascal}', () => {
+    it('should create a new ${entity.humanReadable}', async () => {
+      const input = { /* TODO: Add fields */ };
+      const created = {
+        id: 'new-uuid',
+        ...input,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      };
+      mockCtx.db.${entity.camel}.create.mockResolvedValue(created);
+
+      // TODO: Call procedure and assert
+      expect(mockCtx.db.${entity.camel}.create).toBeDefined();
+    });
+  });
+
+  describe('update${entity.pascal}', () => {
+    it('should update an existing ${entity.humanReadable}', async () => {
+      const input = { id: 'test-uuid', /* TODO: Add fields */ };
+      const updated = {
+        id: 'test-uuid',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      };
+      mockCtx.db.${entity.camel}.update.mockResolvedValue(updated);
+
+      // TODO: Call procedure and assert
+      expect(mockCtx.db.${entity.camel}.update).toBeDefined();
+    });
+  });
+
+  describe('delete${entity.pascal}', () => {
+    it('should delete a ${entity.humanReadable}', async () => {
+      mockCtx.db.${entity.camel}.delete.mockResolvedValue(undefined);
+
+      // TODO: Call procedure and assert
+      expect(mockCtx.db.${entity.camel}.delete).toBeDefined();
+    });
+  });
+});
+`;
+}
+// ============================================================================
+// Path Helpers
+// ============================================================================
+/**
+ * Get the file path for the procedure file
+ */
+export function getNamespaceProcedurePath(entityPlural) {
+    return `src/procedures/${entityPlural}.ts`;
+}
+/**
+ * Get the file path for the test file
+ */
+export function getNamespaceTestPath(entityPlural) {
+    return `src/procedures/__tests__/${entityPlural}.test.ts`;
+}
+/**
+ * Get the file path for the schema file
+ */
+export function getNamespaceSchemaPath(entityKebab) {
+    return `src/schemas/${entityKebab}.ts`;
+}
+/**
+ * Generate post-generation instructions
+ */
+export function getNamespaceInstructions(entityPlural, entityPascal, entityKebab) {
+    return `
+  1. Add the schema export:
+
+     // src/schemas/index.ts
+     export * from './${entityKebab}.js';
+
+  2. Add the procedure export:
+
+     // src/procedures/index.ts
+     export * from './${entityPlural}.js';
+
+  3. Register the procedure collection:
+
+     // src/index.ts (or router.ts)
+     import { ${entityPlural.replace(/-/g, '')}Procedures } from './procedures/index.js';
+
+     const collections = [..., ${entityPlural.replace(/-/g, '')}Procedures];
+
+  4. Add the Prisma model:
+
+     // prisma/schema.prisma
+     model ${entityPascal} {
+       id        String   @id @default(uuid())
+       createdAt DateTime @default(now())
+       updatedAt DateTime @updatedAt
+
+       @@map("${entityPlural.replace(/-/g, '_')}")
+     }
+
+     Then run: pnpm db:push
+`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veloxts/cli",
-  "version": "0.6.64",
+  "version": "0.6.66",
   "description": "Developer tooling and CLI commands for VeloxTS framework",
   "type": "module",
   "main": "dist/index.js",
@@ -40,11 +40,11 @@
     "picocolors": "1.1.1",
     "pluralize": "8.0.0",
     "tsx": "4.21.0",
-    "@veloxts/core": "0.6.64",
-    "@veloxts/auth": "0.6.64",
-    "@veloxts/orm": "0.6.64",
-    "@veloxts/router": "0.6.64",
-    "@veloxts/validation": "0.6.64"
+    "@veloxts/router": "0.6.66",
+    "@veloxts/orm": "0.6.66",
+    "@veloxts/auth": "0.6.66",
+    "@veloxts/validation": "0.6.66",
+    "@veloxts/core": "0.6.66"
   },
   "peerDependencies": {
     "@prisma/client": ">=7.0.0"