@veloxts/cli 0.6.97 → 0.6.98

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @veloxts/cli
 
+## 0.6.98
+
+### Patch Changes
+
+- feat(router): nested resource schema relations with .hasOne() / .hasMany()
+- Updated dependencies
+  - @veloxts/auth@0.6.98
+  - @veloxts/core@0.6.98
+  - @veloxts/orm@0.6.98
+  - @veloxts/router@0.6.98
+  - @veloxts/validation@0.6.98
+
 ## 0.6.97
 
 ### Patch Changes

package/dist/generators/generators/namespace.js

@@ -13,6 +13,8 @@
  */
 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 { detectRouterPattern, isProcedureRegistered, registerProcedures, } from '../utils/router-integration.js';
 // ============================================================================
 // Generator Implementation
@@ -96,9 +98,31 @@ Examples:
      * Generate namespace files
      */
     async generate(config) {
-        const context = this.createContext(config);
+        // Detect relations from existing Prisma model before creating context
+        const enrichedOptions = { ...config.options };
+        const schemaPath = findPrismaSchema(config.cwd);
+        if (schemaPath) {
+            try {
+                const entity = deriveEntityNames(config.entityName);
+                const schemaAnalysis = analyzePrismaSchema(schemaPath);
+                if (hasModel(schemaAnalysis, entity.pascal)) {
+                    const modelRelations = getModelRelations(schemaAnalysis, entity.pascal);
+                    if (modelRelations.hasOne.length > 0 || modelRelations.hasMany.length > 0) {
+                        enrichedOptions.relations = {
+                            hasOne: [...modelRelations.hasOne],
+                            hasMany: [...modelRelations.hasMany],
+                        };
+                    }
+                }
+            }
+            catch {
+                // Schema parsing failed — proceed without relations
+            }
+        }
+        const enrichedConfig = { ...config, options: enrichedOptions };
+        const context = this.createContext(enrichedConfig);
         const { entity } = context;
-        const { options } = config;
+        const { options } = enrichedConfig;
         // Collect files to generate
         const files = [];
         // Generate schema file

package/dist/generators/generators/resource.js

@@ -19,7 +19,7 @@ import { generateInjectablePrismaContent, generateResourceFiles, } from '../temp
 import { findAllSimilarFiles, formatSimilarFilesWarning } from '../utils/filesystem.js';
 import { deriveEntityNames } from '../utils/naming.js';
 import { promptAndRunMigration } from '../utils/prisma-migration.js';
-import { analyzePrismaSchema, findPrismaSchema, hasModel, injectIntoSchema, } from '../utils/prisma-schema.js';
+import { analyzePrismaSchema, findPrismaSchema, getModelRelations, hasModel, injectIntoSchema, } from '../utils/prisma-schema.js';
 import { detectRouterPattern, isProcedureRegistered, registerProcedures, } from '../utils/router-integration.js';
 import { createSnapshot, rollback, saveOriginal, trackCreated, } from '../utils/snapshot.js';
 // ============================================================================
@@ -257,6 +257,26 @@ export class ResourceGenerator extends BaseGenerator {
                 }
             }
         }
+        // Detect relations from existing Prisma schema (if model exists)
+        let relations;
+        const schemaPath = findPrismaSchema(config.cwd);
+        if (schemaPath) {
+            try {
+                const schemaAnalysis = analyzePrismaSchema(schemaPath);
+                if (hasModel(schemaAnalysis, ctx.entity.pascal)) {
+                    const modelRelations = getModelRelations(schemaAnalysis, ctx.entity.pascal);
+                    if (modelRelations.hasOne.length > 0 || modelRelations.hasMany.length > 0) {
+                        relations = {
+                            hasOne: [...modelRelations.hasOne],
+                            hasMany: [...modelRelations.hasMany],
+                        };
+                    }
+                }
+            }
+            catch {
+                // Schema parsing failed — proceed without relations
+            }
+        }
         // Show spinner during actual file generation
         // Only show if we're in interactive mode (we collected fields or user opted to skip)
         const showSpinner = interactive && !skipFields && !config.dryRun;
@@ -265,7 +285,7 @@ export class ResourceGenerator extends BaseGenerator {
             const s = p.spinner();
             s.start('Scaffolding resource...');
             try {
-                generatedFiles = generateResourceFiles(ctx);
+                generatedFiles = generateResourceFiles(ctx, relations);
                 s.stop(`Scaffolded ${generatedFiles.length} file(s)`);
             }
             catch (err) {
@@ -274,7 +294,7 @@ export class ResourceGenerator extends BaseGenerator {
             }
         }
         else {
-            generatedFiles = generateResourceFiles(ctx);
+            generatedFiles = generateResourceFiles(ctx, relations);
         }
         // Auto-registration (skip in dry-run mode)
         let autoResult = {

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

@@ -6,6 +6,15 @@
  * custom procedures rather than pre-defined CRUD operations.
  */
 import type { TemplateContext, TemplateFunction } from '../types.js';
+/**
+ * Relation info for code generation (shared with resource template)
+ */
+export interface RelationInfo {
+    /** Single-object relation field names */
+    hasOne: string[];
+    /** Array relation field names */
+    hasMany: string[];
+}
 export interface NamespaceOptions {
     /** Skip auto-registering in router.ts */
     skipRegistration: boolean;
@@ -13,6 +22,8 @@ export interface NamespaceOptions {
     withExample: boolean;
     /** Generate test file */
     withTests: boolean;
+    /** Detected relations from Prisma schema */
+    relations?: RelationInfo;
 }
 /**
  * Generate namespace procedure file

package/dist/generators/templates/namespace.js

@@ -6,6 +6,21 @@
  * custom procedures rather than pre-defined CRUD operations.
  */
 // ============================================================================
+// Relation Helpers
+// ============================================================================
+/**
+ * Build an `include: { ... }` clause string for Prisma queries
+ */
+function buildIncludeClause(relations) {
+    if (!relations)
+        return '';
+    const allRelations = [...relations.hasOne, ...relations.hasMany];
+    if (allRelations.length === 0)
+        return '';
+    const entries = allRelations.map((name) => `${name}: true`).join(', ');
+    return `\n        include: { ${entries} },`;
+}
+// ============================================================================
 // Template Functions
 // ============================================================================
 /**
@@ -64,7 +79,8 @@ export const ${entity.camel}Procedures = procedures('${entity.plural}', {
  * Generate namespace with example procedure
  */
 function generateWithExample(ctx) {
-    const { entity } = ctx;
+    const { entity, options } = ctx;
+    const includeClause = buildIncludeClause(options.relations);
     return `/**
  * ${entity.pascal} Procedures
  *
@@ -92,7 +108,7 @@ export const ${entity.camel}Procedures = procedures('${entity.plural}', {
     .output(${entity.pascal}Schema.nullable())
     .query(async ({ input, ctx }) => {
       return ctx.db.${entity.camel}.findUnique({
-        where: { id: input.id },
+        where: { id: input.id },${includeClause}
       });
     }),
 
@@ -103,7 +119,7 @@ export const ${entity.camel}Procedures = procedures('${entity.plural}', {
   list${entity.pascalPlural}: procedure()
     .output(z.array(${entity.pascal}Schema))
     .query(async ({ ctx }) => {
-      return ctx.db.${entity.camel}.findMany();
+      return ctx.db.${entity.camel}.findMany(${includeClause ? `{${includeClause}\n      }` : ''});
     }),
 
   /**

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

@@ -88,10 +88,19 @@ export declare function generateInjectablePrismaContent(entity: {
     pascal: string;
     camel: string;
 }, options: ResourceOptions, database?: DatabaseType): InjectablePrismaContent;
+/**
+ * Relation info for code generation
+ */
+export interface RelationInfo {
+    /** Single-object relation field names */
+    hasOne: string[];
+    /** Array relation field names */
+    hasMany: string[];
+}
 /**
  * Generate all files for a resource
  */
-export declare function generateResourceFiles(ctx: TemplateContext<ResourceOptions>): GeneratedFile[];
+export declare function generateResourceFiles(ctx: TemplateContext<ResourceOptions>, relations?: RelationInfo): GeneratedFile[];
 /**
  * Generate post-generation instructions
  */

package/dist/generators/templates/resource.js

@@ -123,6 +123,23 @@ export function generatePrismaEnums(fields) {
     });
     return `\n${enums.join('\n\n')}\n`;
 }
+// ============================================================================
+// Relation Helpers
+// ============================================================================
+/**
+ * Build an `include: { ... }` clause string for Prisma queries
+ *
+ * Returns empty string if no relations, or a formatted include block
+ */
+function buildIncludeClause(relations) {
+    if (!relations)
+        return '';
+    const allRelations = [...relations.hasOne, ...relations.hasMany];
+    if (allRelations.length === 0)
+        return '';
+    const entries = allRelations.map((name) => `${name}: true`).join(', ');
+    return `\n        include: { ${entries} },`;
+}
 /**
  * Generate injectable Prisma content (model + enums without comments)
  *
@@ -334,12 +351,11 @@ export type ${pascal} = z.infer<typeof ${camel}Schema>;
 ${crudSchemas}
 `;
 }
-// ============================================================================
-// Procedure Template
-// ============================================================================
-function generateProcedure(entity, options) {
+function generateProcedure(entity, options, relations) {
     const { pascal, camel, kebab } = entity;
     const { crud, paginated, softDelete } = options;
+    // Build include clause if relations exist
+    const includeClause = buildIncludeClause(relations);
     if (!crud) {
         // Simple procedure without CRUD
         return `/**
@@ -361,7 +377,7 @@ export const ${camel}Procedures = procedures('${kebab}s', {
     .output(${camel}Schema.nullable())
     .query(async ({ input, ctx }) => {
       return ctx.db.${camel}.findUnique({
-        where: { id: input.id },
+        where: { id: input.id },${includeClause}
       });
     }),
 });
@@ -421,7 +437,7 @@ export const ${camel}Procedures = procedures('${kebab}s', {
     .output(${camel}Schema.nullable())
     .query(async ({ input, ctx }) => {
       return ctx.db.${camel}.findUnique({
-        where: { id: input.id${softDeleteWhere} },
+        where: { id: input.id${softDeleteWhere} },${includeClause}
       });
     }),
 
@@ -439,7 +455,7 @@ export const ${camel}Procedures = procedures('${kebab}s', {
         take: input.limit,
         orderBy: input.sortBy
           ? { [input.sortBy]: input.sortOrder }
-          : { createdAt: 'desc' },
+          : { createdAt: 'desc' },${includeClause}
       });
 ${paginationCode}
     }),
@@ -626,7 +642,7 @@ describe('${pascal} Procedures', () => {
 /**
  * Generate all files for a resource
  */
-export function generateResourceFiles(ctx) {
+export function generateResourceFiles(ctx, relations) {
     const files = [];
     const { entity, options, project } = ctx;
     // Prisma model (added to models folder for reference)
@@ -647,7 +663,7 @@ export function generateResourceFiles(ctx) {
     if (!options.skipProcedure) {
         files.push({
             path: `src/procedures/${entity.kebab}.ts`,
-            content: generateProcedure(entity, options),
+            content: generateProcedure(entity, options, relations),
         });
     }
     // Tests

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

@@ -4,6 +4,41 @@
  * Parses Prisma schema files to find models/enums and enables safe injection
  * of new definitions without breaking existing code.
  */
+/**
+ * Parsed information about a single field in a Prisma model
+ */
+export interface PrismaFieldInfo {
+    /** Field name (e.g., 'author', 'posts') */
+    readonly name: string;
+    /** Base type without modifiers (e.g., 'User', 'Post') */
+    readonly type: string;
+    /** Whether this field is a relation to another model */
+    readonly isRelation: boolean;
+    /** Whether this is an array relation (e.g., Post[]) */
+    readonly isArray: boolean;
+    /** The related model name, if this is a relation field */
+    readonly relatedModel: string | undefined;
+}
+/**
+ * Detailed information about a Prisma model including its fields
+ */
+export interface PrismaModelInfo {
+    /** Model name (PascalCase) */
+    readonly name: string;
+    /** All parsed fields */
+    readonly fields: readonly PrismaFieldInfo[];
+    /** Only the relation fields (convenience accessor) */
+    readonly relationFields: readonly PrismaFieldInfo[];
+}
+/**
+ * Relation info categorized for code generation
+ */
+export interface ModelRelations {
+    /** Single-object relations (e.g., author User) */
+    readonly hasOne: readonly string[];
+    /** Array relations (e.g., posts Post[]) */
+    readonly hasMany: readonly string[];
+}
 /**
  * Represents a parsed Prisma schema
  */
@@ -22,6 +57,8 @@ export interface PrismaSchemaAnalysis {
     readonly lastEnumEnd: number;
     /** Position where models start (after datasource/generator blocks) */
     readonly modelSectionStart: number;
+    /** Detailed model info with field-level data */
+    readonly modelDetails: Map<string, PrismaModelInfo>;
 }
 /**
  * Model definition to inject
@@ -64,6 +101,12 @@ export declare function findPrismaSchema(projectRoot: string): string | null;
  * Parse a Prisma schema file
  */
 export declare function analyzePrismaSchema(filePath: string): PrismaSchemaAnalysis;
+/**
+ * Get categorized relations for a model
+ *
+ * Returns hasOne (single-object) and hasMany (array) relation field names
+ */
+export declare function getModelRelations(analysis: PrismaSchemaAnalysis, modelName: string): ModelRelations;
 /**
  * Check if a model exists in the schema
  */

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

@@ -65,6 +65,8 @@ export function analyzePrismaSchema(filePath) {
     if (modelSectionStart === 0) {
         modelSectionStart = findEndOfConfigBlocks(content);
     }
+    // Parse field-level details for each model
+    const modelDetails = parseModelDetails(content, models);
     return {
         content,
         filePath,
@@ -73,6 +75,7 @@ export function analyzePrismaSchema(filePath) {
         lastModelEnd,
         lastEnumEnd,
         modelSectionStart,
+        modelDetails,
     };
 }
 /**
@@ -115,6 +118,103 @@ function findEndOfConfigBlocks(content) {
     return lastEnd;
 }
 // ============================================================================
+// Field-Level Parsing
+// ============================================================================
+/**
+ * Parse detailed field information for all models in the schema
+ */
+function parseModelDetails(content, modelNames) {
+    const details = new Map();
+    const modelRegex = /^model\s+(\w+)\s*\{/gm;
+    for (const match of content.matchAll(modelRegex)) {
+        const modelName = match[1];
+        const blockStart = content.indexOf('{', match.index ?? 0);
+        const blockEnd = findBlockEnd(content, match.index ?? 0);
+        const body = content.slice(blockStart + 1, blockEnd - 1);
+        const fields = parseModelFields(body, modelNames);
+        details.set(modelName, {
+            name: modelName,
+            fields,
+            relationFields: fields.filter((f) => f.isRelation),
+        });
+    }
+    return details;
+}
+/**
+ * Parse individual fields from a model body string
+ *
+ * Detects relation fields by checking if the field type matches a known model name.
+ * Skips back-reference fields (those with @relation(...) that are the inverse side).
+ */
+function parseModelFields(body, modelNames) {
+    const fields = [];
+    const lines = body.split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Skip empty lines, comments, and directives (@@map, @@unique, etc.)
+        if (!trimmed || trimmed.startsWith('//') || trimmed.startsWith('@@')) {
+            continue;
+        }
+        // Parse field: name Type[?][] [@annotations...]
+        // Match: fieldName  TypeName  optional modifiers
+        const fieldMatch = trimmed.match(/^(\w+)\s+(\w+)(\[\])?\??/);
+        if (!fieldMatch)
+            continue;
+        const name = fieldMatch[1];
+        const baseType = fieldMatch[2];
+        const isArray = fieldMatch[3] === '[]';
+        // Check if this is a relation field (type matches a known model)
+        const isRelation = modelNames.has(baseType);
+        if (!isRelation) {
+            fields.push({
+                name,
+                type: baseType,
+                isRelation: false,
+                isArray: false,
+                relatedModel: undefined,
+            });
+            continue;
+        }
+        // For relation fields, skip back-references (inverse side with @relation)
+        // Back-references typically have @relation and reference back to the parent
+        // We detect them by the presence of `fields:` and `references:` in @relation
+        const hasRelationWithForeignKey = /@relation\([^)]*fields:\s*\[/.test(trimmed);
+        if (hasRelationWithForeignKey) {
+            continue;
+        }
+        fields.push({
+            name,
+            type: baseType,
+            isRelation: true,
+            isArray,
+            relatedModel: baseType,
+        });
+    }
+    return fields;
+}
+/**
+ * Get categorized relations for a model
+ *
+ * Returns hasOne (single-object) and hasMany (array) relation field names
+ */
+export function getModelRelations(analysis, modelName) {
+    const modelInfo = analysis.modelDetails.get(modelName);
+    if (!modelInfo) {
+        return { hasOne: [], hasMany: [] };
+    }
+    const hasOne = [];
+    const hasMany = [];
+    for (const field of modelInfo.relationFields) {
+        if (field.isArray) {
+            hasMany.push(field.name);
+        }
+        else {
+            hasOne.push(field.name);
+        }
+    }
+    return { hasOne, hasMany };
+}
+// ============================================================================
 // Schema Modification
 // ============================================================================
 /**

package/package.json

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