@specverse/engines 4.1.5 → 4.1.6

package/dist/libs/instance-factories/applications/templates/generic/backend-env-generator.js

@@ -0,0 +1,22 @@
+function generateBackendEnv(context) {
+  const { spec, manifest } = context;
+  const projectName = (spec.metadata?.component || "app").toLowerCase().replace(/\s+/g, "-");
+  const dbName = `spv_${projectName}_dev`;
+  const dbUser = process.env.USER || "postgres";
+  const port = manifest?.configuration?.environments?.development?.server?.port || 3e3;
+  return `# Backend Environment Configuration
+# Database
+DATABASE_URL="postgresql://${dbUser}:@localhost:5432/${dbName}"
+
+# API Configuration
+PORT=${port}
+HOST=0.0.0.0
+NODE_ENV=development
+
+# CORS
+CORS_ORIGINS="http://localhost:5173"
+`;
+}
+export {
+  generateBackendEnv as default
+};

package/dist/libs/instance-factories/applications/templates/generic/backend-package-json-generator.js

@@ -0,0 +1,66 @@
+function generateBackendPackageJson(context) {
+  const { spec } = context;
+  const appName = (spec.metadata?.component || "app").toLowerCase().replace(/\s+/g, "-");
+  const pkg = {
+    name: `${appName}-backend`,
+    version: spec.metadata?.version || "1.0.0",
+    description: `Backend API for ${spec.metadata?.component || "application"}`,
+    type: "module",
+    bin: {
+      [appName]: "./bin/cli.mjs"
+    },
+    scripts: {
+      // Development
+      "dev": "tsx watch src/main.ts",
+      "dev:debug": "tsx watch --inspect src/main.ts",
+      // Build
+      "build": "tsc",
+      "build:watch": "tsc --watch",
+      // Production
+      "start": "node dist/main.js",
+      // Database
+      "db:setup": "prisma generate && prisma db push",
+      "db:generate": "prisma generate",
+      "db:push": "prisma db push",
+      "db:migrate": "prisma migrate dev",
+      "db:studio": "prisma studio",
+      "db:seed": "tsx prisma/seed.ts",
+      // Testing
+      "test": "vitest run --passWithNoTests",
+      "test:watch": "vitest watch",
+      "test:coverage": "vitest --coverage",
+      // Linting
+      "lint": "eslint src --ext .ts",
+      "lint:fix": "eslint src --ext .ts --fix",
+      // Type checking
+      "typecheck": "tsc --noEmit"
+    },
+    dependencies: {
+      "@prisma/client": "^5.7.0",
+      "fastify": "^4.25.0",
+      "@fastify/cors": "^8.4.0",
+      "@fastify/helmet": "^11.1.1",
+      "@fastify/rate-limit": "^9.1.0",
+      "zod": "^3.22.0",
+      "dotenv": "^16.3.0"
+    },
+    devDependencies: {
+      "typescript": "^5.3.0",
+      "@types/node": "^20.10.0",
+      "tsx": "^4.7.0",
+      "prisma": "^5.7.0",
+      "vitest": "^1.0.0",
+      "@vitest/coverage-v8": "^1.0.0",
+      "eslint": "^8.55.0",
+      "@typescript-eslint/eslint-plugin": "^6.15.0",
+      "@typescript-eslint/parser": "^6.15.0"
+    },
+    engines: {
+      node: ">=18.0.0"
+    }
+  };
+  return JSON.stringify(pkg, null, 2);
+}
+export {
+  generateBackendPackageJson as default
+};

package/dist/libs/instance-factories/applications/templates/generic/backend-tsconfig-generator.js

@@ -0,0 +1,54 @@
+function generateBackendTsConfig(context) {
+  const config = {
+    compilerOptions: {
+      // Target and Module
+      target: "ES2022",
+      module: "ESNext",
+      lib: ["ES2022"],
+      moduleResolution: "node",
+      // Output
+      outDir: "./dist",
+      rootDir: "./src",
+      // Strict Type Checking
+      strict: true,
+      noImplicitAny: true,
+      strictNullChecks: true,
+      strictFunctionTypes: true,
+      strictBindCallApply: true,
+      strictPropertyInitialization: true,
+      noImplicitThis: true,
+      alwaysStrict: true,
+      // Additional Checks
+      noUnusedLocals: true,
+      noUnusedParameters: true,
+      noImplicitReturns: true,
+      noFallthroughCasesInSwitch: true,
+      noUncheckedIndexedAccess: true,
+      // Module Resolution
+      esModuleInterop: true,
+      allowSyntheticDefaultImports: true,
+      resolveJsonModule: true,
+      isolatedModules: true,
+      // Source Maps
+      sourceMap: true,
+      declaration: true,
+      declarationMap: true,
+      // Skip lib check for faster builds
+      skipLibCheck: true,
+      // Emit
+      removeComments: false,
+      importHelpers: true,
+      // Experimental
+      experimentalDecorators: true,
+      emitDecoratorMetadata: true,
+      // Types
+      types: ["node"]
+    },
+    include: ["src/**/*"],
+    exclude: ["node_modules", "dist", "**/*.test.ts", "**/*.spec.ts"]
+  };
+  return JSON.stringify(config, null, 2);
+}
+export {
+  generateBackendTsConfig as default
+};

package/dist/libs/instance-factories/applications/templates/generic/main-generator.js

@@ -0,0 +1,290 @@
+function generateMain(context) {
+  const { spec, manifest } = context;
+  let framework = "fastify";
+  if (manifest.capabilityMappings) {
+    const apiMapping = manifest.capabilityMappings.find(
+      (m) => m.capability === "api.rest"
+    );
+    if (apiMapping?.instanceFactory) {
+      const factoryName = apiMapping.instanceFactory.toLowerCase();
+      if (factoryName.includes("fastify")) framework = "fastify";
+      else if (factoryName.includes("express")) framework = "express";
+      else if (factoryName.includes("nestjs")) framework = "nestjs";
+    }
+  }
+  switch (framework) {
+    case "fastify":
+      return generateFastifyMain(spec);
+    case "express":
+      return generateExpressMain(spec);
+    case "nestjs":
+      return generateNestJSMain(spec);
+    default:
+      throw new Error(`Unsupported framework: ${framework}`);
+  }
+}
+function generateFastifyMain(spec) {
+  const controllers = spec.controllers || [];
+  const services = spec.services || [];
+  const routeImports = controllers.map(
+    (ctrl) => `import ${ctrl.name.replace("Controller", "")}Routes from './routes/${ctrl.name}.js';`
+  ).join("\n");
+  const metaRoutesImport = ``;
+  const serviceImports = services.map(
+    (svc) => `import { ${svc.name} } from './services/${svc.name}.js';`
+  ).join("\n");
+  const controllerImports = controllers.map(
+    (ctrl) => `import { ${ctrl.name} } from './controllers/${ctrl.name}.js';`
+  ).join("\n");
+  const serviceInstantiations = services.map(
+    (svc) => `  const ${svc.name.charAt(0).toLowerCase() + svc.name.slice(1)} = new ${svc.name}(prisma);`
+  ).join("\n");
+  const controllerInstantiations = controllers.map(
+    (ctrl) => `  const ${ctrl.name.charAt(0).toLowerCase() + ctrl.name.slice(1)} = new ${ctrl.name}();`
+  ).join("\n");
+  const serviceMap = services.map(
+    (svc) => `    ${svc.name}: ${svc.name.charAt(0).toLowerCase() + svc.name.slice(1)}`
+  ).join(",\n");
+  const controllerMap = controllers.map(
+    (ctrl) => `    ${ctrl.name}: ${ctrl.name.charAt(0).toLowerCase() + ctrl.name.slice(1)}`
+  ).join(",\n");
+  const routeRegistrations = controllers.map((ctrl) => {
+    let prefix = ctrl.basePath;
+    if (!prefix) {
+      const modelName = ctrl.model || ctrl.name.replace("Controller", "");
+      const pluralModel = modelName.toLowerCase() + "s";
+      prefix = `/api/${pluralModel}`;
+    }
+    return `  await app.register(${ctrl.name.replace("Controller", "")}Routes, {
+    prefix: '${prefix}',
+    controllers: {
+      ${ctrl.name}: ${ctrl.name.charAt(0).toLowerCase() + ctrl.name.slice(1)}
+    },
+    services: services
+  });`;
+  }).join("\n");
+  const specJson = JSON.stringify(spec, null, 2).replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$");
+  return `import Fastify from 'fastify';
+import cors from '@fastify/cors';
+import { PrismaClient } from '@prisma/client';
+${routeImports}
+${metaRoutesImport}
+${serviceImports}
+${controllerImports}
+
+// Embedded specification for /api/spec endpoint
+const spec = ${specJson};
+
+const app = Fastify({
+  logger: {
+    level: process.env.LOG_LEVEL || 'info'
+  }
+});
+
+const prisma = new PrismaClient();
+
+async function start() {
+  try {
+    // Initialize services and controllers
+${serviceInstantiations}
+${controllerInstantiations}
+${controllers.length > 0 ? `
+    const services = {
+${serviceMap}
+    };` : ""}
+
+    // Register plugins
+    await app.register(cors, {
+      origin: true,
+      credentials: true
+    });
+
+    // Spec endpoint \u2014 serves the specification for the runtime frontend
+    app.get('/api/spec', async () => spec);
+
+    // Runtime info endpoint \u2014 models and controllers for DevShell
+    app.get('/api/runtime/info', async () => ({
+      controllers: [${controllers.map((c) => `'${c.name}'`).join(", ")}],
+      models: [${controllers.map((c) => `'${c.model || c.name.replace("Controller", "")}'`).join(", ")}],
+      events: [],
+      services: []
+    }));
+
+    // Register routes
+  // MetaRoutes disabled for now - enable when meta-routes generator is integrated
+  // await app.register(MetaRoutes, {
+  //   prefix: '/api'
+  // });
+${routeRegistrations}
+
+    const preferredPort = process.env.PORT ? parseInt(process.env.PORT) : 3000;
+    const host = process.env.HOST || '0.0.0.0';
+
+    // Try to start server with automatic port fallback
+    let port = preferredPort;
+    let started = false;
+    const maxAttempts = 10;
+
+    for (let i = 0; i < maxAttempts && !started; i++) {
+      port = preferredPort + i;
+      try {
+        await app.listen({ port, host });
+        started = true;
+
+        if (i > 0) {
+          console.log(\`\u26A0\uFE0F  Port \${preferredPort} was in use, using \${port} instead\`);
+        }
+        console.log(\`\u{1F680} Server running on http://\${host}:\${port}\`);
+        console.log(\`\u{1F4DA} Environment: \${process.env.NODE_ENV || 'development'}\`);
+      } catch (err: any) {
+        if (err.code === 'EADDRINUSE' && i < maxAttempts - 1) {
+          // Port in use, try next port
+          continue;
+        } else {
+          // Different error or ran out of attempts
+          throw err;
+        }
+      }
+    }
+
+    if (!started) {
+      throw new Error(\`Could not find available port in range \${preferredPort}-\${preferredPort + maxAttempts - 1}\`);
+    }
+  } catch (err) {
+    app.log.error(err);
+    await prisma.$disconnect();
+    process.exit(1);
+  }
+}
+
+// Handle graceful shutdown
+process.on('SIGINT', async () => {
+  console.log('\\n\u{1F44B} Shutting down gracefully...');
+  await app.close();
+  await prisma.$disconnect();
+  process.exit(0);
+});
+
+process.on('SIGTERM', async () => {
+  console.log('\\n\u{1F44B} Shutting down gracefully...');
+  await app.close();
+  await prisma.$disconnect();
+  process.exit(0);
+});
+
+start();
+`;
+}
+function generateExpressMain(spec) {
+  const controllers = spec.controllers || [];
+  const routeImports = controllers.map(
+    (ctrl) => `import ${ctrl.name.replace("Controller", "")}Router from './routes/${ctrl.name}.js';`
+  ).join("\n");
+  const routeRegistrations = controllers.map(
+    (ctrl) => `app.use('${ctrl.basePath || "/api"}', ${ctrl.name.replace("Controller", "")}Router);`
+  ).join("\n");
+  return `import express from 'express';
+import cors from 'cors';
+${routeImports}
+
+const app = express();
+
+// Middleware
+app.use(cors());
+app.use(express.json());
+
+// Routes
+${routeRegistrations}
+
+async function start() {
+  const preferredPort = process.env.PORT ? parseInt(process.env.PORT) : 3000;
+  const host = process.env.HOST || '0.0.0.0';
+  const maxAttempts = 10;
+
+  // Try to start server with automatic port fallback
+  for (let i = 0; i < maxAttempts; i++) {
+    const port = preferredPort + i;
+    try {
+      await new Promise((resolve, reject) => {
+        const server = app.listen(port, host, () => {
+          if (i > 0) {
+            console.log(\`\u26A0\uFE0F  Port \${preferredPort} was in use, using \${port} instead\`);
+          }
+          console.log(\`\u{1F680} Server running on http://\${host}:\${port}\`);
+          console.log(\`\u{1F4DA} Environment: \${process.env.NODE_ENV || 'development'}\`);
+          resolve(server);
+        }).on('error', (err: any) => {
+          if (err.code === 'EADDRINUSE' && i < maxAttempts - 1) {
+            resolve(null); // Try next port
+          } else {
+            reject(err);
+          }
+        });
+      });
+      break; // Successfully started
+    } catch (err) {
+      if (i === maxAttempts - 1) {
+        console.error(\`Could not find available port in range \${preferredPort}-\${preferredPort + maxAttempts - 1}\`);
+        process.exit(1);
+      }
+    }
+  }
+}
+
+start();
+
+export default app;
+`;
+}
+function generateNestJSMain(spec) {
+  return `import { NestFactory } from '@nestjs/core';
+import { AppModule } from './app.module.js';
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule, {
+    logger: ['log', 'error', 'warn', 'debug', 'verbose']
+  });
+
+  app.enableCors({
+    origin: true,
+    credentials: true
+  });
+
+  const preferredPort = process.env.PORT ? parseInt(process.env.PORT) : 3000;
+  const host = process.env.HOST || '0.0.0.0';
+  const maxAttempts = 10;
+
+  // Try to start server with automatic port fallback
+  let started = false;
+  for (let i = 0; i < maxAttempts && !started; i++) {
+    const port = preferredPort + i;
+    try {
+      await app.listen(port, host);
+      started = true;
+
+      if (i > 0) {
+        console.log(\`\u26A0\uFE0F  Port \${preferredPort} was in use, using \${port} instead\`);
+      }
+      console.log(\`\u{1F680} Server running on http://\${host}:\${port}\`);
+      console.log(\`\u{1F4DA} Environment: \${process.env.NODE_ENV || 'development'}\`);
+    } catch (err: any) {
+      if (err.code === 'EADDRINUSE' && i < maxAttempts - 1) {
+        // Port in use, try next port
+        continue;
+      } else {
+        throw err;
+      }
+    }
+  }
+
+  if (!started) {
+    throw new Error(\`Could not find available port in range \${preferredPort}-\${preferredPort + maxAttempts - 1}\`);
+  }
+}
+
+bootstrap();
+`;
+}
+export {
+  generateMain as default
+};