@specverse/engines 4.1.5 → 4.1.6

package/dist/libs/instance-factories/services/templates/prisma/step-conventions.js

@@ -0,0 +1,264 @@
+function toVar(name) {
+  return name.charAt(0).toLowerCase() + name.slice(1);
+}
+function toMethod(words) {
+  return words.trim().replace(/\s+(.)/g, (_, c) => c.toUpperCase()).replace(/^\w/, (c) => c.toLowerCase());
+}
+const STEP_CONVENTIONS = [
+  // --- Validation ---
+  {
+    name: "validate",
+    pattern: /^validate\s+(.+)/i,
+    generateCall: (m, ctx) => `    // Step ${ctx.stepNum}: Validate ${m[1]}
+    const validationResult = this.validate(params, { operation: '${ctx.operationName}' });
+    if (!validationResult.valid) {
+      throw new Error(\`Validation failed: \${validationResult.errors.join(', ')}\`);
+    }`
+  },
+  // --- Check / Guard ---
+  {
+    name: "check",
+    pattern: /^check\s+(.+)/i,
+    generateCall: (m, ctx) => {
+      const condition = m[1];
+      const methodName = toMethod("check " + condition);
+      return `    // Step ${ctx.stepNum}: Check ${condition}
+    const checkResult = await this.${methodName}(params);
+    if (!checkResult) {
+      throw new Error('Check failed: ${condition}');
+    }`;
+    },
+    generateMethod: (m, ctx) => {
+      const condition = m[1];
+      const methodName = toMethod("check " + condition);
+      return `
+  private async ${methodName}(params: any): Promise<boolean> {
+    // TODO: Implement check \u2014 ${condition}
+    const ${toVar(ctx.prismaModel)} = await this.prisma.${toVar(ctx.prismaModel)}.findUnique({ where: { id: params.id } });
+    if (!${toVar(ctx.prismaModel)}) return false;
+    return true;
+  }`;
+    }
+  },
+  // --- Find / Lookup ---
+  {
+    name: "find",
+    pattern: /^find\s+(\w+)\s+by\s+(\w+)/i,
+    generateCall: (m, ctx) => {
+      const model = m[1];
+      const field = m[2];
+      return `    // Step ${ctx.stepNum}: Find ${model} by ${field}
+    const ${toVar(model)} = await this.prisma.${toVar(model)}.findUnique({ where: { ${field}: params.${field} } });
+    if (!${toVar(model)}) {
+      throw new Error('${model} not found by ${field}');
+    }`;
+    }
+  },
+  // --- Create ---
+  {
+    name: "create",
+    pattern: /^create\s+(\w+)(?:\s+record)?/i,
+    generateCall: (m, ctx) => {
+      const model = m[1];
+      return `    // Step ${ctx.stepNum}: Create ${model}
+    const ${toVar(model)} = await this.prisma.${toVar(model)}.create({ data: params });`;
+    }
+  },
+  // --- Update field ---
+  {
+    name: "update-field",
+    pattern: /^update\s+(\w+)\s+(\w+)\s+to\s+(.+)/i,
+    generateCall: (m, ctx) => {
+      const model = m[1];
+      const field = m[2];
+      const value = m[3].trim().replace(/"/g, "'");
+      const isString = /^[a-z]/.test(value) && !value.includes(".");
+      const val = isString ? `'${value}'` : value;
+      return `    // Step ${ctx.stepNum}: Update ${model} ${field} to ${value}
+    await this.prisma.${toVar(model)}.update({
+      where: { id: params.id },
+      data: { ${field}: ${val} },
+    });`;
+    }
+  },
+  // --- Generic update ---
+  {
+    name: "update",
+    pattern: /^update\s+(\w+)(?:\s+(.+))?/i,
+    generateCall: (m, ctx) => {
+      const model = m[1];
+      return `    // Step ${ctx.stepNum}: Update ${model}
+    await this.prisma.${toVar(model)}.update({
+      where: { id: params.id },
+      data: params,
+    });`;
+    }
+  },
+  // --- Delete ---
+  {
+    name: "delete",
+    pattern: /^delete\s+(\w+)/i,
+    generateCall: (m, ctx) => {
+      const model = m[1];
+      return `    // Step ${ctx.stepNum}: Delete ${model}
+    await this.prisma.${toVar(model)}.delete({ where: { id: params.id } });`;
+    }
+  },
+  // --- Transition / Evolve ---
+  {
+    name: "transition",
+    pattern: /^transition\s+(\w+)\s+to\s+(\w+)/i,
+    generateCall: (m, ctx) => {
+      const model = m[1];
+      const state = m[2];
+      return `    // Step ${ctx.stepNum}: Transition ${model} to ${state}
+    const current = await this.prisma.${toVar(model)}.findUniqueOrThrow({ where: { id: params.id } });
+    // Lifecycle validation would check valid transition here
+    await this.prisma.${toVar(model)}.update({
+      where: { id: params.id },
+      data: { status: '${state}' },
+    });`;
+    }
+  },
+  // --- Set field ---
+  {
+    name: "set",
+    pattern: /^set\s+(\w+)\s+to\s+(.+)/i,
+    generateCall: (m, ctx) => {
+      const field = m[1];
+      const value = m[2].trim();
+      const isCurrentTime = /current time|now|timestamp/i.test(value);
+      const val = isCurrentTime ? "new Date()" : `'${value}'`;
+      return `    // Step ${ctx.stepNum}: Set ${field} to ${value}
+    await this.prisma.${toVar(ctx.prismaModel)}.update({
+      where: { id: params.id },
+      data: { ${field}: ${val} },
+    });`;
+    }
+  },
+  // --- Increment ---
+  {
+    name: "increment",
+    pattern: /^increment\s+(\w+)\s+by\s+(\w+)/i,
+    generateCall: (m, ctx) => {
+      const field = m[1];
+      const amount = m[2];
+      const amountVal = /^\d+$/.test(amount) ? amount : `params.${amount}`;
+      return `    // Step ${ctx.stepNum}: Increment ${field} by ${amount}
+    await this.prisma.${toVar(ctx.prismaModel)}.update({
+      where: { id: params.id },
+      data: { ${field}: { increment: ${amountVal} } },
+    });`;
+    }
+  },
+  // --- Decrement ---
+  {
+    name: "decrement",
+    pattern: /^decrement\s+(\w+)\s+by\s+(\w+)/i,
+    generateCall: (m, ctx) => {
+      const field = m[1];
+      const amount = m[2];
+      const amountVal = /^\d+$/.test(amount) ? amount : `params.${amount}`;
+      return `    // Step ${ctx.stepNum}: Decrement ${field} by ${amount}
+    const current${field} = await this.prisma.${toVar(ctx.prismaModel)}.findUniqueOrThrow({ where: { id: params.id } });
+    if ((current${field}.${field} || 0) < ${amountVal}) {
+      throw new Error('Cannot decrement ${field} below zero');
+    }
+    await this.prisma.${toVar(ctx.prismaModel)}.update({
+      where: { id: params.id },
+      data: { ${field}: { decrement: ${amountVal} } },
+    });`;
+    }
+  },
+  // --- Calculate ---
+  {
+    name: "calculate",
+    pattern: /^calculate\s+(.+)/i,
+    generateCall: (m, ctx) => {
+      const metric = m[1];
+      const methodName = toMethod("calculate " + metric);
+      return `    // Step ${ctx.stepNum}: Calculate ${metric}
+    const ${toVar(metric.replace(/\s+/g, ""))} = await this.${methodName}(params);`;
+    },
+    generateMethod: (m, ctx) => {
+      const metric = m[1];
+      const methodName = toMethod("calculate " + metric);
+      return `
+  private async ${methodName}(params: any): Promise<number> {
+    // TODO: Implement calculation \u2014 ${metric}
+    return 0;
+  }`;
+    }
+  },
+  // --- Send event ---
+  {
+    name: "send-event",
+    pattern: /^(?:send|emit|publish)\s+(\w+)\s+event/i,
+    generateCall: (m, ctx) => {
+      const event = m[1];
+      return `    // Step ${ctx.stepNum}: Emit ${event} event
+    this.emit('${event}', { ${toVar(ctx.prismaModel)}Id: params.id, operation: '${ctx.operationName}', timestamp: new Date().toISOString() });`;
+    }
+  },
+  // --- Send notification ---
+  {
+    name: "send-notification",
+    pattern: /^send\s+(\w+)\s+notification/i,
+    generateCall: (m, ctx) => {
+      const type = m[1];
+      return `    // Step ${ctx.stepNum}: Send ${type} notification
+    this.emit('${type}Notification', { ${toVar(ctx.prismaModel)}Id: params.id, operation: '${ctx.operationName}' });`;
+    }
+  },
+  // --- Call service ---
+  {
+    name: "call-service",
+    pattern: /^call\s+(\w+)\.(\w+)/i,
+    generateCall: (m, ctx) => {
+      const service = m[1];
+      const method = m[2];
+      return `    // Step ${ctx.stepNum}: Call ${service}.${method}
+    await this.${toVar(service)}.${method}(params);`;
+    }
+  },
+  // --- Return ---
+  {
+    name: "return",
+    pattern: /^return\s+(.+)/i,
+    generateCall: (m, ctx) => {
+      const value = m[1].trim();
+      const isModel = /^(updated|created|the)\s+/i.test(value) || value === ctx.modelName;
+      if (isModel) {
+        return `    // Step ${ctx.stepNum}: Return result
+    return ${toVar(ctx.prismaModel)};`;
+      }
+      return `    // Step ${ctx.stepNum}: Return ${value}
+    return ${value};`;
+    }
+  }
+];
+function matchStep(step, ctx) {
+  for (const convention of STEP_CONVENTIONS) {
+    const match = step.match(convention.pattern);
+    if (match) {
+      return {
+        call: convention.generateCall(match, ctx),
+        helperMethod: convention.generateMethod?.(match, ctx)
+      };
+    }
+  }
+  const methodName = toMethod(step);
+  return {
+    call: `    // Step ${ctx.stepNum}: ${step}
+    await this.${methodName}(params);`,
+    helperMethod: `
+  private async ${methodName}(params: any): Promise<void> {
+    // TODO: Implement \u2014 ${step}
+    throw new Error('Not implemented: ${methodName}');
+  }`
+  };
+}
+export {
+  STEP_CONVENTIONS,
+  matchStep
+};

package/dist/libs/instance-factories/services/templates/shared-patterns.js

@@ -0,0 +1,24 @@
+const CONVENTION_PATTERNS = [
+  { name: "validate", pattern: /^validate\s+(.+)/i, description: "Validate input data" },
+  { name: "check-no-existing", pattern: /^check\s+(?:no\s+existing|.*has\s+no\s+existing)\s+(\w+)\s+for\s+(\w+)\s+in\s+(\w+)/i, description: "Check no duplicate entity exists for a pair" },
+  { name: "check", pattern: /^check\s+(.+)/i, description: "Check a condition" },
+  { name: "find", pattern: /^find\s+(\w+)\s+by\s+(\w+)/i, description: "Find entity by field" },
+  { name: "find-all-for", pattern: /^find\s+(?:all\s+)?(\w+?)s?\s+(?:for|of|belonging\s+to)\s+(\w+)/i, description: "Cross-model query via foreign key" },
+  { name: "count-per", pattern: /^count\s+(\w+?)s?\s+(?:per|by|for\s+each)\s+(\w+)/i, description: "Group-by aggregation count" },
+  { name: "create", pattern: /^create\s+(\w+)(?:\s+record)?/i, description: "Create a new entity" },
+  { name: "update-field", pattern: /^update\s+(\w+)\s+(\w+)\s+to\s+(.+)/i, description: "Update specific field to value" },
+  { name: "update", pattern: /^update\s+(\w+)$/i, description: "Update entity with params" },
+  { name: "delete", pattern: /^delete\s+(\w+)/i, description: "Delete an entity" },
+  { name: "transition", pattern: /^transition\s+(\w+)\s+to\s+(\w+)/i, description: "Lifecycle state transition" },
+  { name: "set", pattern: /^set\s+(\w+)\s+to\s+(.+)/i, description: "Set a field value" },
+  { name: "increment", pattern: /^increment\s+(\w+)\s+by\s+(\w+)/i, description: "Increment numeric field" },
+  { name: "decrement", pattern: /^decrement\s+(\w+)\s+by\s+(\w+)/i, description: "Decrement numeric field" },
+  { name: "calculate", pattern: /^calculate\s+(.+)/i, description: "Calculate metric or aggregation" },
+  { name: "send-event", pattern: /^(?:send|emit|publish)\s+(\w+)\s+event/i, description: "Publish domain event" },
+  { name: "send-notification", pattern: /^send\s+(\w+)\s+notification/i, description: "Send notification event" },
+  { name: "call-service", pattern: /^call\s+(\w+)\.(\w+)/i, description: "Delegate to another service" },
+  { name: "return", pattern: /^return\s+(.+)/i, description: "Return a value" }
+];
+export {
+  CONVENTION_PATTERNS
+};

package/dist/libs/instance-factories/shared/path-resolver.js

@@ -0,0 +1,59 @@
+function resolvePath(relativePath, target, config = {}) {
+  const {
+    outputStructure = "monorepo",
+    backendDir = "backend",
+    frontendDir = "frontend",
+    baseDir = "."
+  } = config;
+  if (outputStructure === "standalone") {
+    return baseDir === "." ? relativePath : `${baseDir}/${relativePath}`;
+  }
+  const prefix = target === "backend" ? backendDir : target === "frontend" ? frontendDir : "shared";
+  return `${prefix}/${relativePath}`;
+}
+function resolveImportPath(from, to, importPath, config = {}) {
+  const { outputStructure = "monorepo" } = config;
+  if (outputStructure === "standalone") {
+    if (from === "frontend" && to === "backend") {
+      throw new Error("Frontend cannot directly import from backend in standalone mode. Use API calls.");
+    }
+    return importPath;
+  }
+  if (from === to) {
+    return importPath;
+  }
+  if (from === "frontend" && to === "shared") {
+    return `../../shared/${importPath}`;
+  }
+  if (from === "backend" && to === "shared") {
+    return `../../shared/${importPath}`;
+  }
+  return importPath;
+}
+function getApiBaseUrl(config) {
+  const { outputStructure = "monorepo", apiBaseUrl } = config;
+  if (apiBaseUrl) {
+    return apiBaseUrl;
+  }
+  if (outputStructure === "standalone") {
+    return "${VITE_API_BASE_URL}";
+  }
+  const port = config.serverPort || 3e3;
+  return `http://localhost:${port}`;
+}
+function getPathConfig(context) {
+  return {
+    outputStructure: context.configuration?.outputStructure || "monorepo",
+    backendDir: context.configuration?.backendDir || "backend",
+    frontendDir: context.configuration?.frontendDir || "frontend",
+    baseDir: context.configuration?.baseDir || ".",
+    apiBaseUrl: context.configuration?.apiBaseUrl,
+    serverPort: context.configuration?.environments?.development?.server?.port || context.manifest?.configuration?.environments?.development?.server?.port
+  };
+}
+export {
+  getApiBaseUrl,
+  getPathConfig,
+  resolveImportPath,
+  resolvePath
+};

package/dist/libs/instance-factories/storage/templates/mongodb/config-generator.js

@@ -0,0 +1,13 @@
+function generateMongoDBConfig(context) {
+  const { instance } = context;
+  const instanceName = instance?.name || "mongodb";
+  return `// MongoDB configuration for ${instanceName}
+// TODO: Implement full MongoDB config generator
+export const mongoConfig = {
+  url: process.env.MONGO_URL || 'mongodb://localhost:27017/${instanceName}'
+};
+`;
+}
+export {
+  generateMongoDBConfig as default
+};

package/dist/libs/instance-factories/storage/templates/mongodb/docker-generator.js

@@ -0,0 +1,16 @@
+function generateMongoDBDocker(context) {
+  const { instance } = context;
+  const instanceName = instance?.name || "mongodb";
+  return `# MongoDB Docker Compose for ${instanceName}
+# TODO: Implement full MongoDB docker generator
+version: '3.8'
+services:
+  ${instanceName}:
+    image: mongo:6
+    ports:
+      - "27017:27017"
+`;
+}
+export {
+  generateMongoDBDocker as default
+};

package/dist/libs/instance-factories/storage/templates/postgresql/config-generator.js

@@ -0,0 +1,45 @@
+function generatePostgreSQLConfig(context) {
+  const { instance, implType } = context;
+  const config = implType.configuration || {};
+  const instanceName = instance?.name || "default";
+  return `/**
+ * PostgreSQL Database Configuration
+ * Instance: ${instanceName}
+ * Generated from SpecVerse specification
+ */
+
+import { Pool, PoolConfig } from 'pg';
+
+export const ${instanceName}Config: PoolConfig = {
+  host: process.env.${instanceName.toUpperCase()}_DB_HOST || ${JSON.stringify(config.host || "localhost")},
+  port: parseInt(process.env.${instanceName.toUpperCase()}_DB_PORT || '${config.port || 5432}'),
+  database: process.env.${instanceName.toUpperCase()}_DB_NAME || ${JSON.stringify(config.database || "app")},
+  user: process.env.${instanceName.toUpperCase()}_DB_USER,
+  password: process.env.${instanceName.toUpperCase()}_DB_PASSWORD,
+
+  // Connection pool settings
+  min: ${config.pool?.min || 2},
+  max: ${config.pool?.max || 10},
+  idleTimeoutMillis: ${config.pool?.idleTimeoutMillis || 3e4},
+  connectionTimeoutMillis: ${config.pool?.connectionTimeoutMillis || 2e3},
+
+  // Performance settings
+  statement_timeout: 30000,
+  query_timeout: 30000,
+};
+
+// Create connection pool
+export const ${instanceName}Pool = new Pool(${instanceName}Config);
+
+// Handle pool errors
+${instanceName}Pool.on('error', (err) => {
+  console.error('Unexpected error on idle PostgreSQL client (${instanceName})', err);
+  process.exit(-1);
+});
+
+export default ${instanceName}Pool;
+`;
+}
+export {
+  generatePostgreSQLConfig as default
+};

package/dist/libs/instance-factories/storage/templates/postgresql/docker-generator.js

@@ -0,0 +1,46 @@
+function generatePostgreSQLDocker(context) {
+  const { instance, implType } = context;
+  const config = implType.configuration || {};
+  const instanceName = instance?.name || "postgres";
+  return `# PostgreSQL Docker Compose Configuration
+# Instance: ${instanceName}
+# Generated from SpecVerse specification
+
+version: '3.8'
+
+services:
+  ${instanceName}:
+    image: postgres:15-alpine
+    container_name: ${instanceName}
+    restart: unless-stopped
+
+    ports:
+      - "\${${instanceName.toUpperCase()}_DB_PORT:-${config.port || 5432}}:5432"
+
+    environment:
+      POSTGRES_DB: \${${instanceName.toUpperCase()}_DB_NAME:-app}
+      POSTGRES_USER: \${${instanceName.toUpperCase()}_DB_USER:-postgres}
+      POSTGRES_PASSWORD: \${${instanceName.toUpperCase()}_DB_PASSWORD}
+
+      # Performance settings
+      POSTGRES_MAX_CONNECTIONS: ${config.settings?.max_connections || 100}
+      POSTGRES_SHARED_BUFFERS: ${config.settings?.shared_buffers || "256MB"}
+
+    volumes:
+      - ${instanceName}_data:/var/lib/postgresql/data
+      - ./init-scripts:/docker-entrypoint-initdb.d
+
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U \${${instanceName.toUpperCase()}_DB_USER:-postgres}"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+
+volumes:
+  ${instanceName}_data:
+    driver: local
+`;
+}
+export {
+  generatePostgreSQLDocker as default
+};

package/dist/libs/instance-factories/storage/templates/redis/config-generator.js

@@ -0,0 +1,14 @@
+function generateRedisConfig(context) {
+  const { instance } = context;
+  const instanceName = instance?.name || "redis";
+  return `// Redis configuration for ${instanceName}
+// TODO: Implement full Redis config generator
+export const redisConfig = {
+  host: process.env.REDIS_HOST || 'localhost',
+  port: parseInt(process.env.REDIS_PORT || '6379')
+};
+`;
+}
+export {
+  generateRedisConfig as default
+};

package/dist/libs/instance-factories/storage/templates/redis/docker-generator.js

@@ -0,0 +1,16 @@
+function generateRedisDocker(context) {
+  const { instance } = context;
+  const instanceName = instance?.name || "redis";
+  return `# Redis Docker Compose for ${instanceName}
+# TODO: Implement full Redis docker generator
+version: '3.8'
+services:
+  ${instanceName}:
+    image: redis:7-alpine
+    ports:
+      - "6379:6379"
+`;
+}
+export {
+  generateRedisDocker as default
+};

package/dist/libs/instance-factories/test-generation.js

@@ -0,0 +1,145 @@
+import { createDefaultLibrary, createResolver, createCodeGenerator, loadManifest } from "@specverse/engines/realize";
+import { UnifiedSpecVerseParser } from "@specverse/engine-parser";
+import { readFileSync } from "fs";
+import { resolve } from "path";
+async function testV33Generation() {
+  console.log("\u{1F9EA} Testing v3.3 Implementation Types System\n");
+  try {
+    console.log("\u{1F4DA} Step 1: Loading Implementation Type Library...");
+    const library = await createDefaultLibrary(process.cwd());
+    const allTypes = library.find({});
+    console.log(`   \u2705 Library loaded with ${allTypes.length} implementation types`);
+    allTypes.forEach((type) => {
+      console.log(`   - ${type.name} v${type.version} (${type.type})`);
+    });
+    console.log();
+    console.log("\u{1F4C4} Step 2: Loading v3.3 Manifest...");
+    const manifestPath = resolve(process.cwd(), "examples/v33-test/fastify-prisma-manifest.yaml");
+    const manifest = loadManifest(manifestPath);
+    console.log(`   \u2705 Manifest loaded: ${manifest.name}`);
+    console.log(`   - Version: ${manifest.version}`);
+    console.log(`   - Implementation Types: ${manifest.implementationTypes?.length || 0}`);
+    console.log(`   - Capability Mappings: ${Object.keys(manifest.capabilityMappings || {}).length}`);
+    console.log();
+    console.log("\u{1F50D} Step 3: Creating Capability Resolver...");
+    const resolver = createResolver(library, manifest);
+    console.log(`   \u2705 Resolver created`);
+    console.log();
+    console.log("\u{1F4DD} Step 4: Parsing Test Spec...");
+    const specPath = resolve(process.cwd(), "examples/01-fundamentals/01-01-basic-model.specly");
+    const specContent = readFileSync(specPath, "utf8");
+    const schemaPath = resolve(process.cwd(), "schema/SPECVERSE-SCHEMA.json");
+    const schema = JSON.parse(readFileSync(schemaPath, "utf8"));
+    const parser = new UnifiedSpecVerseParser(schema);
+    const parseResult = parser.parse(specContent, "specly");
+    if (parseResult.errors && parseResult.errors.length > 0) {
+      console.error("   \u274C Parse errors:");
+      parseResult.errors.forEach((err) => {
+        console.error(`      - ${err.message}`);
+      });
+      return;
+    }
+    console.log(`   \u2705 Spec parsed successfully`);
+    console.log(`   - Component: ${parseResult.ast?.components ? Object.keys(parseResult.ast.components)[0] : "unknown"}`);
+    console.log(`   - Models: ${parseResult.ast?.components?.[Object.keys(parseResult.ast.components)[0]]?.models?.length || 0}`);
+    console.log(`   - Controllers: ${parseResult.ast?.components?.[Object.keys(parseResult.ast.components)[0]]?.controllers?.length || 0}`);
+    const deployment = {
+      environment: "development",
+      instances: {
+        "apiServer": {
+          name: "Test API Server",
+          type: "api-server",
+          advertises: ["api.rest", "api.rest.crud"],
+          uses: ["storage.database"]
+        },
+        "database": {
+          name: "Test Database",
+          type: "storage",
+          advertises: ["storage.database", "storage.prisma"],
+          uses: []
+        }
+      }
+    };
+    console.log(`   - Mocked deployment for testing`);
+    console.log(`   - Instances: ${Object.keys(deployment.instances || {}).length}`);
+    console.log();
+    console.log("\u{1F517} Step 5: Testing Capability Resolution...");
+    const apiInstance = deployment.instances?.["apiServer"];
+    if (!apiInstance) {
+      console.error("   \u274C No api-server instance found");
+      return;
+    }
+    console.log(`   Testing instance: ${apiInstance.name}`);
+    console.log(`   Advertises: ${apiInstance.advertises?.join(", ")}`);
+    const resolved = resolver.resolveForInstance(apiInstance);
+    console.log(`   \u2705 Resolved ${resolved.length} implementation type(s)`);
+    resolved.forEach((impl2) => {
+      console.log(`   - ${impl2.implementationType.name}`);
+      console.log(`     Capability: ${impl2.capability}`);
+      console.log(`     Templates: ${Object.keys(impl2.implementationType.codeTemplates).join(", ")}`);
+    });
+    console.log();
+    console.log("\u2699\uFE0F  Step 6: Testing Code Generation...");
+    const codeGen = createCodeGenerator({ outputDir: "/tmp/v33-test" });
+    const componentName = Object.keys(parseResult.ast?.components || {})[0];
+    const component = parseResult.ast?.components?.[componentName];
+    const model = component?.models?.[0];
+    const controller = component?.controllers?.[0] || {
+      name: `${model?.name}Controller`,
+      path: `/api/${model?.name?.toLowerCase()}`,
+      model: model?.name,
+      endpoints: [
+        { operation: "create", method: "POST", path: "/" },
+        { operation: "retrieve", method: "GET", path: "/:id" },
+        { operation: "update", method: "PUT", path: "/:id" },
+        { operation: "delete", method: "DELETE", path: "/:id" },
+        { operation: "list", method: "GET", path: "/" }
+      ]
+    };
+    if (!model) {
+      console.error("   \u274C No model found in spec");
+      return;
+    }
+    console.log(`   Generating code for model: ${model.name}`);
+    const impl = resolved[0];
+    const templates = ["routes", "services", "schema"];
+    for (const templateName of templates) {
+      try {
+        console.log(`   Testing ${templateName} template...`);
+        const output = await codeGen.generateFromTemplate(
+          impl,
+          templateName,
+          {
+            spec: parseResult.ast,
+            model,
+            controller,
+            models: [model]
+          },
+          { outputDir: "/tmp/v33-test" }
+        );
+        console.log(`   \u2705 ${templateName}: ${output.filePath}`);
+        console.log(`      Code length: ${output.code.length} characters`);
+        console.log(`      First 100 chars: ${output.code.substring(0, 100)}...`);
+      } catch (error) {
+        console.error(`   \u274C ${templateName} failed: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    console.log();
+    console.log("\u2705 All tests completed!");
+    console.log("\n\u{1F4CA} Summary:");
+    console.log(`   - Library: \u2705 Loaded`);
+    console.log(`   - Manifest: \u2705 Loaded`);
+    console.log(`   - Spec: \u2705 Parsed`);
+    console.log(`   - Resolution: \u2705 Working`);
+    console.log(`   - Generation: \u2705 Working`);
+    console.log("\n\u{1F389} v3.3 Implementation Types System is operational!");
+  } catch (error) {
+    console.error("\n\u274C Test failed:", error instanceof Error ? error.message : String(error));
+    if (error instanceof Error && error.stack) {
+      console.error("\nStack trace:");
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+}
+testV33Generation();

package/dist/libs/instance-factories/testing/templates/vitest/tests-generator.js

@@ -0,0 +1,30 @@
+import { generateTests } from "../../../../../scripts/generate-tests.js";
+function generateTestSuite(context) {
+  const { spec, implType, outputDir } = context;
+  if (!spec) {
+    throw new Error("Specification is required in template context");
+  }
+  const config = implType.configuration || {};
+  const options = {
+    testFramework: config.testFramework || "vitest",
+    generateUnitTests: config.generateUnitTests !== false,
+    generateIntegrationTests: config.generateIntegrationTests !== false,
+    generateE2ETests: config.generateE2ETests !== false,
+    generateFixtures: config.generateFixtures !== false,
+    generateMocks: config.generateMocks !== false
+  };
+  const result = generateTests(spec, outputDir || "./tests", options);
+  return JSON.stringify({
+    message: "Test suite generated successfully",
+    unitTests: result.unitTests,
+    integrationTests: result.integrationTests,
+    e2eTests: result.e2eTests,
+    fixtureCount: result.fixtureCount,
+    mockCount: result.mockCount,
+    outputDir: result.outputDir,
+    files: result.files
+  }, null, 2);
+}
+export {
+  generateTestSuite as default
+};