@specverse/engines 4.1.5 → 4.1.6

package/dist/libs/instance-factories/orms/templates/prisma/services-generator.js

@@ -0,0 +1,266 @@
+function generatePrismaService(context) {
+  const { model, controller, spec, implType } = context;
+  if (!model) {
+    throw new Error("Model is required in template context");
+  }
+  const modelName = model.name;
+  const serviceName = `${modelName}Service`;
+  const prismaModel = modelName.charAt(0).toLowerCase() + modelName.slice(1);
+  const imports = generateImports(modelName, implType);
+  const methods = generateCRUDEMethods(modelName, prismaModel, model, implType);
+  const validateMethod = generateValidationMethod(modelName, model, implType);
+  return `${imports}
+
+/**
+ * ${serviceName}
+ * Generated service for ${modelName} model
+ *
+ * Provides CURED operations (Create, Retrieve, Update, Evolve, Delete)
+ * with Prisma ORM integration
+ */
+export class ${serviceName} {
+  constructor(private prisma: PrismaClient) {}
+
+${methods}
+
+${validateMethod}
+}
+`;
+}
+function generateImports(modelName, implType) {
+  const imports = [
+    `import { PrismaClient, ${modelName} } from '@prisma/client';`
+  ];
+  return imports.join("\n");
+}
+function generateCRUDEMethods(modelName, prismaModel, model, implType) {
+  const methods = [];
+  methods.push(generateCreateMethod(modelName, prismaModel, model));
+  methods.push(generateRetrieveMethod(modelName, prismaModel, model));
+  methods.push(generateUpdateMethod(modelName, prismaModel, model));
+  methods.push(generateEvolveMethod(modelName, prismaModel, model));
+  methods.push(generateDeleteMethod(modelName, prismaModel, model));
+  methods.push(generateListMethod(modelName, prismaModel, model));
+  return methods.join("\n\n");
+}
+function generateCreateMethod(modelName, prismaModel, model) {
+  return `  /**
+   * Create a new ${modelName}
+   */
+  async create(data: Omit<${modelName}, 'id' | 'createdAt' | 'updatedAt'>): Promise<${modelName}> {
+    // Validate before creating
+    const validationResult = this.validate(data, { operation: 'create' });
+    if (!validationResult.valid) {
+      throw new Error(\`Validation failed: \${validationResult.errors.join(', ')}\`);
+    }
+
+    return await this.prisma.${prismaModel}.create({
+      data: data as any
+    });
+  }`;
+}
+function generateRetrieveMethod(modelName, prismaModel, model) {
+  return `  /**
+   * Retrieve a ${modelName} by ID
+   */
+  async retrieve(id: string): Promise<${modelName} | null> {
+    return await this.prisma.${prismaModel}.findUnique({
+      where: { id }
+    });
+  }`;
+}
+function generateUpdateMethod(modelName, prismaModel, model) {
+  return `  /**
+   * Update a ${modelName}
+   */
+  async update(id: string, data: Partial<${modelName}>): Promise<${modelName}> {
+    // Validate before updating
+    const validationResult = this.validate(data, { operation: 'update' });
+    if (!validationResult.valid) {
+      throw new Error(\`Validation failed: \${validationResult.errors.join(', ')}\`);
+    }
+
+    return await this.prisma.${prismaModel}.update({
+      where: { id },
+      data: data as any
+    });
+  }`;
+}
+function generateEvolveMethod(modelName, prismaModel, model) {
+  const hasLifecycle = model.lifecycle && model.lifecycle.length > 0;
+  if (hasLifecycle) {
+    return `  /**
+   * Evolve a ${modelName} (lifecycle-aware update)
+   * Handles state transitions according to lifecycle rules
+   */
+  async evolve(id: string, data: Partial<${modelName}>): Promise<${modelName}> {
+    // Get current instance to check state
+    const current = await this.retrieve(id);
+    if (!current) {
+      throw new Error('${modelName} not found');
+    }
+
+    // Validate state transition if status is being changed
+    if (data.status && data.status !== current.status) {
+      // TODO: Add lifecycle validation based on model.lifecycle
+      // For now, allow any transition
+    }
+
+    // Validate data
+    const validationResult = this.validate(data, { operation: 'evolve' });
+    if (!validationResult.valid) {
+      throw new Error(\`Validation failed: \${validationResult.errors.join(', ')}\`);
+    }
+
+    return await this.prisma.${prismaModel}.update({
+      where: { id },
+      data: data as any
+    });
+  }`;
+  } else {
+    return `  /**
+   * Evolve a ${modelName} (same as update for models without lifecycle)
+   */
+  async evolve(id: string, data: Partial<${modelName}>): Promise<${modelName}> {
+    return this.update(id, data);
+  }`;
+  }
+}
+function generateDeleteMethod(modelName, prismaModel, model) {
+  const hasSoftDelete = model.metadata?.softDelete;
+  if (hasSoftDelete) {
+    return `  /**
+   * Delete a ${modelName} (soft delete)
+   */
+  async delete(id: string): Promise<void> {
+    await this.prisma.${prismaModel}.update({
+      where: { id },
+      data: {
+        deletedAt: new Date(),
+        isDeleted: true
+      }
+    });
+  }`;
+  } else {
+    return `  /**
+   * Delete a ${modelName}
+   */
+  async delete(id: string): Promise<void> {
+    await this.prisma.${prismaModel}.delete({
+      where: { id }
+    });
+  }`;
+  }
+}
+function generateListMethod(modelName, prismaModel, model) {
+  const hasSoftDelete = model.metadata?.softDelete;
+  const whereClause = hasSoftDelete ? `
+      where: { isDeleted: false },` : "";
+  return `  /**
+   * List all ${modelName}s
+   */
+  async list(): Promise<${modelName}[]> {
+    return await this.prisma.${prismaModel}.findMany({${whereClause}
+      orderBy: { createdAt: 'desc' }
+    });
+  }`;
+}
+function generateValidationMethod(modelName, model, implType) {
+  return `  /**
+   * Validate ${modelName} data
+   * Unified validation method for all operations
+   */
+  validate(
+    data: any,
+    context: { operation: 'create' | 'update' | 'evolve' }
+  ): { valid: boolean; errors: string[] } {
+    const errors: string[] = [];
+
+    // Required field validation (for create operation)
+    if (context.operation === 'create') {
+      ${generateRequiredFieldValidation(model)}
+    }
+
+    // Type validation
+    ${generateTypeValidation(model)}
+
+    // Constraint validation
+    ${generateConstraintValidation(model)}
+
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }`;
+}
+function generateRequiredFieldValidation(model) {
+  const requiredFields = model.attributes?.filter(
+    (attr) => attr.constraints?.required && !["id", "createdAt", "updatedAt"].includes(attr.name)
+  ) || [];
+  if (requiredFields.length === 0) {
+    return "// No required fields";
+  }
+  const validations = requiredFields.map(
+    (field) => `if (data.${field.name} === undefined || data.${field.name} === null) {
+        errors.push('${field.name} is required');
+      }`
+  ).join("\n      ");
+  return validations;
+}
+function generateTypeValidation(model) {
+  const fields = model.attributes || [];
+  if (fields.length === 0) {
+    return "// No type validation";
+  }
+  const validations = fields.filter((field) => !["id", "createdAt", "updatedAt"].includes(field.name)).map((field) => {
+    const typeName = inferJsType(field.type);
+    if (typeName === "string" || typeName === "number" || typeName === "boolean") {
+      return `if (data.${field.name} !== undefined && typeof data.${field.name} !== '${typeName}') {
+        errors.push('${field.name} must be a ${typeName}');
+      }`;
+    }
+    return "";
+  }).filter((v) => v).join("\n    ");
+  return validations || "// No type validation needed";
+}
+function generateConstraintValidation(model) {
+  const fields = model.attributes?.filter(
+    (attr) => attr.constraints && Object.keys(attr.constraints).length > 0
+  ) || [];
+  if (fields.length === 0) {
+    return "// No constraint validation";
+  }
+  const validations = fields.map((field) => {
+    const constraints = [];
+    if (field.constraints.unique) {
+      constraints.push(`// TODO: Check uniqueness of ${field.name}`);
+    }
+    if (field.constraints.min !== void 0) {
+      constraints.push(
+        `if (data.${field.name} !== undefined && data.${field.name} < ${field.constraints.min}) {
+        errors.push('${field.name} must be at least ${field.constraints.min}');
+      }`
+      );
+    }
+    if (field.constraints.max !== void 0) {
+      constraints.push(
+        `if (data.${field.name} !== undefined && data.${field.name} > ${field.constraints.max}) {
+        errors.push('${field.name} must be at most ${field.constraints.max}');
+      }`
+      );
+    }
+    return constraints.join("\n    ");
+  }).filter((v) => v).join("\n    ");
+  return validations || "// No constraint validation needed";
+}
+function inferJsType(type) {
+  const typeLower = type.toLowerCase();
+  if (typeLower.includes("string") || typeLower.includes("text")) return "string";
+  if (typeLower.includes("int") || typeLower.includes("number")) return "number";
+  if (typeLower.includes("bool")) return "boolean";
+  if (typeLower.includes("date")) return "object";
+  return "any";
+}
+export {
+  generatePrismaService as default
+};

package/dist/libs/instance-factories/scaffolding/templates/generic/env-example-generator.js

@@ -0,0 +1,51 @@
+function generateEnvExample(context) {
+  const { manifest } = context;
+  const envVars = aggregateEnvironmentVariables(context.implementationTypes || []);
+  const byCategory = {};
+  for (const envVar of envVars) {
+    const category = envVar.category || "Configuration";
+    if (!byCategory[category]) {
+      byCategory[category] = [];
+    }
+    byCategory[category].push(envVar);
+  }
+  const lines = [
+    "# Environment Configuration",
+    "# Copy this file to .env and fill in your values",
+    ""
+  ];
+  for (const [category, vars] of Object.entries(byCategory)) {
+    lines.push(`# ${category}`);
+    for (const envVar of vars) {
+      if (envVar.description) {
+        lines.push(`# ${envVar.description}`);
+      }
+      if (envVar.required) {
+        lines.push(`# REQUIRED`);
+      }
+      const value = envVar.example || "";
+      lines.push(`${envVar.name}="${value}"`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function aggregateEnvironmentVariables(implementationTypes) {
+  const envVarsMap = /* @__PURE__ */ new Map();
+  if (!implementationTypes || implementationTypes.length === 0) {
+    return [];
+  }
+  for (const implType of implementationTypes) {
+    if (implType.requirements?.environment) {
+      for (const envVar of implType.requirements.environment) {
+        if (!envVarsMap.has(envVar.name)) {
+          envVarsMap.set(envVar.name, envVar);
+        }
+      }
+    }
+  }
+  return Array.from(envVarsMap.values());
+}
+export {
+  generateEnvExample as default
+};

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

@@ -0,0 +1,61 @@
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+function generateEnv(context) {
+  const { manifest } = context;
+  const envVars = aggregateEnvironmentVariables(context.implementationTypes || []);
+  let parentDatabaseUrl;
+  try {
+    const parentEnvPath = join(process.cwd(), ".env");
+    if (existsSync(parentEnvPath)) {
+      const parentEnvContent = readFileSync(parentEnvPath, "utf-8");
+      const match = parentEnvContent.match(/DATABASE_URL=["']?([^"'\n]+)["']?/);
+      if (match) {
+        parentDatabaseUrl = match[1];
+      }
+    }
+  } catch (err) {
+  }
+  const byCategory = {};
+  for (const envVar of envVars) {
+    const category = envVar.category || "Configuration";
+    if (!byCategory[category]) {
+      byCategory[category] = [];
+    }
+    byCategory[category].push(envVar);
+  }
+  const lines = [];
+  for (const [category, vars] of Object.entries(byCategory)) {
+    lines.push(`# ${category}`);
+    for (const envVar of vars) {
+      if (envVar.description) {
+        lines.push(`# ${envVar.description}`);
+      }
+      let value = envVar.example || "";
+      if (envVar.name === "DATABASE_URL" && parentDatabaseUrl) {
+        value = parentDatabaseUrl;
+      }
+      lines.push(`${envVar.name}="${value}"`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function aggregateEnvironmentVariables(implementationTypes) {
+  const envVarsMap = /* @__PURE__ */ new Map();
+  if (!implementationTypes || implementationTypes.length === 0) {
+    return [];
+  }
+  for (const implType of implementationTypes) {
+    if (implType.requirements?.environment) {
+      for (const envVar of implType.requirements.environment) {
+        if (!envVarsMap.has(envVar.name)) {
+          envVarsMap.set(envVar.name, envVar);
+        }
+      }
+    }
+  }
+  return Array.from(envVarsMap.values());
+}
+export {
+  generateEnv as default
+};

package/dist/libs/instance-factories/scaffolding/templates/generic/gitignore-generator.js

@@ -0,0 +1,59 @@
+function generateGitIgnore(context) {
+  const { manifest } = context;
+  const ignorePatterns = [
+    "# Dependencies",
+    "node_modules/",
+    "",
+    "# Build output",
+    "dist/",
+    "build/",
+    "",
+    "# Environment",
+    ".env",
+    ".env.local",
+    ".env.*.local",
+    "",
+    "# TypeScript",
+    "*.tsbuildinfo",
+    "",
+    "# Logs",
+    "logs/",
+    "*.log",
+    "npm-debug.log*",
+    ""
+  ];
+  if (usesPrisma(manifest)) {
+    ignorePatterns.push(
+      "# Prisma",
+      "prisma/migrations/",
+      ""
+    );
+  }
+  ignorePatterns.push(
+    "# IDE",
+    ".vscode/",
+    ".idea/",
+    "*.swp",
+    "*.swo",
+    "",
+    "# OS",
+    ".DS_Store",
+    "Thumbs.db",
+    "",
+    "# Testing",
+    "coverage/",
+    ".nyc_output/"
+  );
+  return ignorePatterns.join("\n");
+}
+function usesPrisma(manifest) {
+  if (!manifest || !manifest.capabilityMappings) {
+    return false;
+  }
+  return manifest.capabilityMappings.some(
+    (m) => m.instanceFactory?.toLowerCase().includes("prisma")
+  );
+}
+export {
+  generateGitIgnore as default
+};

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

@@ -0,0 +1,126 @@
+function generatePackageJson(context) {
+  const { spec, manifest, configuration } = context;
+  const outputStructure = configuration?.outputStructure || "monorepo";
+  const isMonorepo = outputStructure === "monorepo";
+  const aggregated = aggregateRequirements(context.instanceFactories || context.implementationTypes || []);
+  const pkg = {
+    name: (spec.metadata?.component || "specverse-app").toLowerCase().replace(/\s+/g, "-"),
+    version: spec.metadata?.version || "1.0.0",
+    description: spec.metadata?.description || "",
+    private: true,
+    type: "module"
+  };
+  if (isMonorepo) {
+    const frontendDir = configuration?.frontendDir || "frontend";
+    const backendDir = configuration?.backendDir || "backend";
+    pkg.workspaces = [backendDir, frontendDir];
+    pkg.scripts = {
+      // Build all workspaces
+      "build": "npm run build --workspaces",
+      "build:backend": `npm run build --workspace=${backendDir}`,
+      "build:frontend": `npm run build --workspace=${frontendDir}`,
+      // Production
+      "start": `npm run start --workspace=${backendDir}`,
+      // Development
+      "dev": "npm run dev --workspaces",
+      "dev:backend": `npm run dev --workspace=${backendDir}`,
+      "dev:frontend": `npm run dev --workspace=${frontendDir}`,
+      // Testing
+      "test": "npm test --workspaces",
+      "test:backend": `npm test --workspace=${backendDir}`,
+      "test:frontend": `npm test --workspace=${frontendDir}`,
+      // Database management (backend)
+      "db:setup": `npm run db:setup --workspace=${backendDir}`,
+      "db:generate": `npm run db:generate --workspace=${backendDir}`,
+      "db:push": `npm run db:push --workspace=${backendDir}`,
+      "db:migrate": `npm run db:migrate --workspace=${backendDir}`,
+      "db:studio": `npm run db:studio --workspace=${backendDir}`,
+      // Linting
+      "lint": "npm run lint --workspaces",
+      "lint:fix": "npm run lint:fix --workspaces"
+    };
+  } else {
+    pkg.scripts = {
+      ...aggregated.scripts,
+      // Ensure we have build script if TypeScript
+      ...aggregated.usesTypeScript && !aggregated.scripts.build && {
+        build: "tsc"
+      },
+      // Add database setup script
+      "db:setup": `node -e "const{execSync:e}=require('child_process');const{readFileSync:r}=require('fs');try{const d=r('.env','utf8').match(/DATABASE_URL=.*\\/([^?\\"]+)/)?.[1];if(!d)throw new Error('DATABASE_URL not found');console.log('Creating database:',d);try{e('createdb '+d)}catch(err){const errMsg=err.stderr?err.stderr.toString():err.message;if(errMsg.includes('already exists')){console.log('\u2705 Database already exists')}else throw err}console.log('\u2705 Database created successfully')}catch(err){console.error('\u274C Database setup failed:',err.message);process.exit(1)}"`,
+      // Add test script if not provided by implementation types
+      ...!aggregated.scripts.test && {
+        test: 'echo "Error: no test specified" && exit 1'
+      }
+    };
+    pkg.dependencies = aggregated.dependencies;
+    pkg.devDependencies = {
+      ...aggregated.devDependencies,
+      // Ensure TypeScript is present if needed
+      ...aggregated.usesTypeScript && !aggregated.devDependencies.typescript && {
+        typescript: "^5.3.0",
+        "@types/node": "^20.0.0"
+      }
+    };
+    if (aggregated.usesTypeScript) {
+      pkg.main = "dist/main.js";
+      pkg.types = "dist/main.d.ts";
+    }
+  }
+  pkg.engines = {
+    node: ">=18.0.0"
+  };
+  return JSON.stringify(pkg, null, 2);
+}
+function aggregateRequirements(implementationTypes) {
+  const result = {
+    dependencies: {},
+    devDependencies: {},
+    scripts: {},
+    environment: [],
+    usesTypeScript: false,
+    usesDocker: false
+  };
+  if (!implementationTypes || implementationTypes.length === 0) {
+    return result;
+  }
+  for (const implType of implementationTypes) {
+    if (implType.dependencies) {
+      if (implType.dependencies.runtime && Array.isArray(implType.dependencies.runtime)) {
+        for (const dep of implType.dependencies.runtime) {
+          if (dep.name && dep.version) {
+            result.dependencies[dep.name] = dep.version;
+          }
+        }
+      }
+      if (implType.dependencies.dev && Array.isArray(implType.dependencies.dev)) {
+        for (const dep of implType.dependencies.dev) {
+          if (dep.name && dep.version) {
+            result.devDependencies[dep.name] = dep.version;
+          }
+        }
+      }
+    }
+    const requirements = implType.requirements;
+    if (requirements) {
+      if (requirements.dependencies?.npm) {
+        Object.assign(result.dependencies, requirements.dependencies.npm.dependencies || {});
+        Object.assign(result.devDependencies, requirements.dependencies.npm.devDependencies || {});
+        Object.assign(result.scripts, requirements.dependencies.npm.scripts || {});
+      }
+      if (requirements.environment) {
+        result.environment.push(...requirements.environment);
+      }
+    }
+    if (implType.technology?.language === "typescript") {
+      result.usesTypeScript = true;
+    }
+    if (implType.capabilities?.provides?.includes("container.dev")) {
+      result.usesDocker = true;
+    }
+  }
+  return result;
+}
+export {
+  generatePackageJson as default
+};