@specverse/engines 4.1.9 → 4.1.11

package/libs/instance-factories/controllers/templates/fastify/routes-generator.ts

@@ -5,6 +5,7 @@
  */
 
 import type { TemplateContext } from '@specverse/types';
+import { inferHttpMethod as sharedInferHttpMethod, inferPath as sharedInferPath, curedToEndpoints as sharedCuredToEndpoints } from '@specverse/types/spec-rules';
 
 /**
  * Generate Fastify routes for a controller
@@ -309,81 +310,31 @@ function inferOperationFromMethodAndPath(method: string, path: string): string {
 }
 
 /**
- * Infer HTTP method from operation name
+ * Infer HTTP method from operation name (delegates to shared spec-rules)
  */
 function inferHttpMethod(operation: string): string {
-  if (!operation) {
-    console.warn('Warning: undefined operation in inferHttpMethod');
-    return 'post'; // default
-  }
-  const opLower = operation.toLowerCase();
-
-  if (opLower === 'create' || opLower === 'validate') return 'post';
-  if (opLower === 'retrieve' || opLower === 'list') return 'get';
-  if (opLower === 'update' || opLower === 'evolve') return 'put';
-  if (opLower === 'delete') return 'delete';
-
-  return 'post'; // default
+  return sharedInferHttpMethod(operation);
 }
 
 /**
- * Infer path from operation name
- * Returns relative path (without base path) for use with Fastify route prefix
+ * Infer path from operation name.
+ * Delegates to shared spec-rules for standard CURVED ops,
+ * handles custom service operation paths locally.
  */
 function inferPath(operation: string, endpoint: any): string {
-  // Endpoint paths from AI view generator are placeholders - ignore them
-  // Always generate relative paths from operation for Fastify route registration
-  // (The prefix is set in main.ts registration, e.g., prefix: '/api/users')
-
-  const opLower = operation.toLowerCase();
-
-  if (opLower === 'create') return '/';
-  if (opLower === 'list') return '/';
-  if (opLower === 'retrieve') return '/:id';
-  if (opLower === 'update') return '/:id';
-  if (opLower === 'evolve') return '/:id/evolve';
-  if (opLower === 'delete') return '/:id';
-  if (opLower === 'validate') return '/validate';
-
   // For custom actions, extract relative path from endpoint.path
-  // e.g., "/user/attach-profile" → "/attach-profile"
-  if (endpoint.path && endpoint.serviceOperation?.type === 'custom') {
+  if (endpoint?.path && endpoint.serviceOperation?.type === 'custom') {
     const pathParts = endpoint.path.split('/').filter((p: string) => p);
     const lastPart = pathParts[pathParts.length - 1];
     return `/${lastPart}`;
   }
 
-  return `/${opLower}`;
+  return sharedInferPath(operation);
 }
 
 /**
- * Convert CURED operations to endpoints
+ * Convert CURED operations to endpoints (delegates to shared spec-rules)
  */
-function curedToEndpoints(cured: any, modelName: string): any[] {
-  const endpoints: any[] = [];
-
-  // Map CURED operations to endpoints with correct paths
-  if (cured.create) {
-    endpoints.push({ operation: 'create', method: 'POST' });
-  }
-  if (cured.retrieve) {
-    endpoints.push({ operation: 'retrieve', method: 'GET' });
-  }
-  if (cured.retrieve_many) {
-    endpoints.push({ operation: 'list', method: 'GET' });
-  }
-  if (cured.update) {
-    endpoints.push({ operation: 'update', method: 'PUT' });
-  }
-  if (cured.evolve) {
-    endpoints.push({ operation: 'evolve', method: 'PATCH' });
-  }
-  if (cured.delete) {
-    endpoints.push({ operation: 'delete', method: 'DELETE' });
-  }
-  if (cured.validate) {
-    endpoints.push({ operation: 'validate', method: 'POST' });
-  }
-
-  return endpoints;
+function curedToEndpoints(cured: any, _modelName: string): any[] {
+  return sharedCuredToEndpoints(cured);
 }

package/libs/instance-factories/controllers/templates/fastify/server-generator.ts

@@ -5,75 +5,7 @@
  */
 
 import type { TemplateContext } from '@specverse/types';
-
-/**
- * Generate Fastify server bootstrap
- */
-/**
- * Normalize spec data for frontend consumption.
- * Converts array-format attributes/relationships/lifecycles to object format.
- * Ensures model references are single strings, not arrays.
- */
-function normalizeSpec(spec: any): any {
-  if (!spec) return spec;
-  const normalized = { ...spec };
-
-  // Normalize models
-  if (normalized.models && typeof normalized.models === 'object') {
-    for (const [name, model] of Object.entries(normalized.models) as [string, any][]) {
-      // Attributes: [{name:'id', type:'UUID'}] → {id: {type:'UUID'}}
-      if (Array.isArray(model.attributes)) {
-        const obj: Record<string, any> = {};
-        for (const attr of model.attributes) {
-          if (attr.name) obj[attr.name] = attr;
-        }
-        model.attributes = obj;
-      }
-      // Relationships: [{name:'author', type:'belongsTo', target:'Author'}] → {author: {..., targetModel:'Author'}}
-      if (Array.isArray(model.relationships)) {
-        const obj: Record<string, any> = {};
-        for (const rel of model.relationships) {
-          if (rel.name) obj[rel.name] = { ...rel, targetModel: rel.target || rel.targetModel };
-        }
-        model.relationships = obj;
-      }
-      // Lifecycles: [{name:'status', states:[...]}] → {status: {states:[...]}}
-      if (Array.isArray(model.lifecycles)) {
-        const obj: Record<string, any> = {};
-        for (const lc of model.lifecycles) {
-          if (lc.name) obj[lc.name] = lc;
-        }
-        model.lifecycles = obj;
-      }
-      // Parse flow strings in lifecycles: "draft -> open -> closed" → states + transitions
-      if (model.lifecycles && typeof model.lifecycles === 'object') {
-        for (const lc of Object.values(model.lifecycles) as any[]) {
-          if (lc.flow && typeof lc.flow === 'string' && !lc.states) {
-            const stateNames = lc.flow.split('->').map((s: string) => s.trim()).filter(Boolean);
-            lc.states = stateNames.map((s: string) => ({ name: s }));
-            lc.transitions = [];
-            lc.initialState = stateNames[0];
-            for (let i = 0; i < stateNames.length - 1; i++) {
-              lc.transitions.push({ from: stateNames[i], to: stateNames[i + 1] });
-            }
-          }
-        }
-      }
-    }
-  }
-
-  // Normalize views — ensure model is a single string
-  if (normalized.views && typeof normalized.views === 'object') {
-    for (const view of Object.values(normalized.views) as any[]) {
-      if (Array.isArray(view.model)) {
-        view.models = view.model; // preserve full list
-        view.model = view.model[0]; // primary model is first
-      }
-    }
-  }
-
-  return normalized;
-}
+import { normalizeSpec, deriveBasePath } from '@specverse/types/spec-rules';
 
 export default function generateFastifyServer(context: TemplateContext): string {
   const { spec, models } = context;
@@ -88,7 +20,7 @@ export default function generateFastifyServer(context: TemplateContext): string
   ).join('\n');
 
   const routeRegistrations = modelNames.map((name: string) => {
-    const path = `/api/${name.toLowerCase()}s`;
+    const path = deriveBasePath(name);
     return `  await fastify.register(${name}Routes, { prefix: '${path}', controllers: { ${name}Controller: new (await import('./controllers/${name}Controller.js')).${name}Controller() } });`;
   }).join('\n');
 

package/libs/instance-factories/orms/templates/prisma/schema-generator.ts

@@ -479,8 +479,24 @@ function generateRelationship(rel: any, model: any, relationMap: Map<string, str
       }
       relationDef += `fields: [${fkBase}], references: [id]`;
 
-      if (rel.onDelete) {
-        relationDef += `, onDelete: ${rel.onDelete}`;
+      // Check if parent model declares cascade on its hasMany/hasOne side
+      let onDelete = rel.onDelete;
+      if (!onDelete && allModels) {
+        const parentModel = allModels.find((m: any) => m.name === rel.target);
+        if (parentModel) {
+          const parentRels = Array.isArray(parentModel.relationships)
+            ? parentModel.relationships
+            : Object.values(parentModel.relationships || {});
+          const parentRel = parentRels.find((pr: any) =>
+            (pr.type === 'hasMany' || pr.type === 'hasOne') &&
+            (pr.target === model.name || pr.targetModel === model.name));
+          if (parentRel?.cascade || parentRel?.cascadeDelete) {
+            onDelete = 'Cascade';
+          }
+        }
+      }
+      if (onDelete) {
+        relationDef += `, onDelete: ${onDelete}`;
       }
       if (rel.onUpdate) {
         relationDef += `, onUpdate: ${rel.onUpdate}`;

package/libs/instance-factories/services/templates/prisma/controller-generator.ts

@@ -6,6 +6,7 @@
  */
 
 import type { TemplateContext } from '@specverse/types';
+import { buildTransitionMap, isAutoField } from '@specverse/types/spec-rules';
 
 /**
  * Generate Prisma controller for a model
@@ -106,12 +107,9 @@ function generateValidationLogic(model: any, dataParam: string = '_data', contex
   const attrList = Array.isArray(model.attributes)
     ? model.attributes.map((a: any) => [a.name, a])
     : Object.entries(model.attributes);
-  // Fields that are auto-generated and should not be required on create
-  const AUTO_FIELDS = new Set(['id', 'createdAt', 'updatedAt', 'created_at', 'updated_at', 'createdBy', 'updatedBy']);
-
   attrList.forEach(([name, attr]: [string, any]) => {
-    // Required validation — skip auto-generated fields
-    if (attr.required && !attr.auto && !AUTO_FIELDS.has(name)) {
+    // Required validation — skip auto-generated fields (uses shared spec-rules)
+    if (attr.required && !isAutoField(name, attr)) {
       validations.push(`
     // ${name} is required
     if (${contextParam}.operation === 'create' && !${dataParam}.${name}) {
@@ -288,25 +286,8 @@ function generateEvolveMethod(model: any, modelName: string, modelVar: string, c
   const lifecycleName = lifecycle?.name || 'status';
   const states = lifecycle?.states || [];
 
-  // Build transition map from the lifecycle flow
-  const validTransitions: Record<string, string[]> = {};
-  if (states.length > 1) {
-    for (let i = 0; i < states.length - 1; i++) {
-      validTransitions[states[i]] = [states[i + 1]];
-    }
-  }
-  // Add cancel transitions if spec defines them
-  if (lifecycle?.transitions) {
-    const transitions = Array.isArray(lifecycle.transitions) ? lifecycle.transitions :
-      Object.entries(lifecycle.transitions).map(([name, t]: [string, any]) => ({ name, ...t }));
-    for (const t of transitions) {
-      const fromStates = Array.isArray(t.from) ? t.from : [t.from];
-      for (const from of fromStates) {
-        if (!validTransitions[from]) validTransitions[from] = [];
-        if (!validTransitions[from].includes(t.to)) validTransitions[from].push(t.to);
-      }
-    }
-  }
+  // Build transition map using shared spec-rules
+  const validTransitions = lifecycle ? buildTransitionMap(lifecycle) : {};
 
   return `
   /**

package/libs/instance-factories/views/templates/react/forms-generator.ts

@@ -158,19 +158,10 @@ function generateSchemaFields(model: any): string {
   const fields: string[] = [];
 
   for (const [name, config] of Object.entries(attributes)) {
-    // Skip standard auto-generated fields
-    if (name === 'id' || name === 'createdAt' || name === 'updatedAt') continue;
-
     const attr: any = config;
 
-    // Skip fields with auto directive (auto=uuid4, auto=now, etc.)
-    if (attr.auto || attr.autoGenerate) continue;
-
-    // Skip common auto-timestamp fields (workaround for parser not preserving auto directive)
-    const autoTimestampFields = ['joinedAt', 'registeredAt', 'enrolledAt', 'startedAt', 'completedAt', 'verifiedAt'];
-    if (autoTimestampFields.includes(name) && (attr.type === 'DateTime' || attr.type === 'Timestamp')) {
-      continue;
-    }
+    // Skip metadata fields (category set at parse time)
+    if (attr.category === 'metadata') continue;
 
     const type = attr.type || 'String';
     let zodType = 'z.string()';
@@ -229,19 +220,10 @@ function generateFormFields(model: any): string {
   const textAreaFields: string[] = [];
 
   for (const [name, config] of Object.entries(attributes)) {
-    // Skip standard auto-generated fields
-    if (name === 'id' || name === 'createdAt' || name === 'updatedAt') continue;
-
     const attr: any = config;
 
-    // Skip fields with auto directive (auto=uuid4, auto=now, etc.)
-    if (attr.auto || attr.autoGenerate) continue;
-
-    // Skip common auto-timestamp fields (workaround for parser not preserving auto directive)
-    const autoTimestampFields = ['joinedAt', 'registeredAt', 'enrolledAt', 'startedAt', 'completedAt', 'verifiedAt'];
-    if (autoTimestampFields.includes(name) && (attr.type === 'DateTime' || attr.type === 'Timestamp')) {
-      continue;
-    }
+    // Skip metadata fields (category set at parse time)
+    if (attr.category === 'metadata') continue;
 
     const type = attr.type || 'String';
     const label = name.charAt(0).toUpperCase() + name.slice(1);

package/libs/instance-factories/views/templates/react/shared-utils-generator.ts

@@ -51,9 +51,17 @@ export function isMetadataField(name: string): boolean {
  */
 export function getEntityDisplayName(entity: any): string {
   if (!entity) return 'Unknown';
-  for (const field of ['name', 'title', 'displayName', 'label', 'username', 'email', 'subject']) {
+  const METADATA = new Set(['id', 'createdAt', 'updatedAt', 'createdBy', 'updatedBy', 'deletedAt', 'version']);
+  // Check common name fields first
+  for (const field of ['name', 'title', 'displayName', 'label', 'username', 'email', 'subject', 'message', 'description']) {
     if (entity[field]) return String(entity[field]);
   }
+  // Fall back to first non-metadata string value
+  for (const [key, val] of Object.entries(entity)) {
+    if (!METADATA.has(key) && val && typeof val === 'string' && !String(val).match(/^[0-9a-f-]{36}$/i)) {
+      return String(val);
+    }
+  }
   return entity.id ? String(entity.id).slice(0, 8) + '...' : 'Unknown';
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@specverse/engines",
-  "version": "4.1.9",
+  "version": "4.1.11",
   "description": "SpecVerse toolchain — parser, inference, realize, generators, AI, registry",
   "type": "module",
   "main": "dist/index.js",