@specverse/engines 4.1.5 → 4.1.6

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

@@ -0,0 +1,413 @@
+function generatePrismaController(context) {
+  const { controller, model, spec, models: allModels } = context;
+  if (!controller) {
+    throw new Error("Controller is required in template context");
+  }
+  if (!model) {
+    throw new Error("Model is required for controller generation");
+  }
+  const controllerName = controller.name;
+  const modelName = model.name;
+  const rawModelVar = modelName.charAt(0).toLowerCase() + modelName.slice(1);
+  const RESERVED_WORDS = /* @__PURE__ */ new Set(["import", "export", "default", "class", "function", "return", "delete", "new", "this", "switch", "case", "break", "continue", "for", "while", "do", "if", "else", "try", "catch", "finally", "throw", "typeof", "instanceof", "in", "of", "let", "const", "var", "void", "with", "yield", "async", "await", "enum", "implements", "interface", "package", "private", "protected", "public", "static", "super", "extends"]);
+  const modelVar = RESERVED_WORDS.has(rawModelVar) ? `${rawModelVar}Item` : rawModelVar;
+  const curedOps = controller.cured || {};
+  const idAttr = (Array.isArray(model.attributes) ? model.attributes : Object.values(model.attributes || {})).find((a) => a.name === "id");
+  const idType = idAttr?.type || "UUID";
+  const needsIntParse = idType === "Integer" || idType === "Int" || idType === "Number";
+  return `/**
+ * ${controllerName}
+ * Model-specific business logic for ${modelName}
+ * ${controller.description || ""}
+ */
+
+import { PrismaClient } from '@prisma/client';
+${hasEventPublishing(curedOps, controller) ? `import { eventBus, EventName } from '../events/eventBus.js';` : ""}
+
+const prisma = new PrismaClient();
+
+/** Parse ID from string to the correct type for this model */
+function parseId(id: string): ${needsIntParse ? "number" : "string"} {
+  ${needsIntParse ? "return parseInt(id, 10);" : "return id;"}
+}
+
+/**
+ * ${controllerName} class
+ */
+export class ${controllerName} {
+  ${generateValidateMethod(model, modelName)}
+  ${curedOps.create ? generateCreateMethod(model, modelName, modelVar, controller, allModels) : ""}
+  ${curedOps.retrieve ? generateRetrieveMethod(model, modelName, modelVar) : ""}
+  ${curedOps.update ? generateUpdateMethod(model, modelName, modelVar, controller, allModels) : ""}
+  ${curedOps.evolve ? generateEvolveMethod(model, modelName, modelVar, controller) : ""}
+  ${curedOps.delete ? generateDeleteMethod(model, modelName, modelVar, controller) : ""}
+  ${generateCustomActions(controller, modelName, modelVar)}
+}
+
+// Export singleton instance
+export const ${modelVar}Controller = new ${controllerName}();
+export default ${modelVar}Controller;
+`;
+}
+function generateValidateMethod(model, modelName) {
+  return `
+  /**
+   * Validate ${modelName} data
+   * Unified validation method for all operations
+   */
+  public validate(
+    _data: any,
+    _context: { operation: 'create' | 'update' | 'evolve' }
+  ): { valid: boolean; errors: string[] } {
+    const errors: string[] = [];
+
+    ${generateValidationLogic(model, "_data", "_context")}
+
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+`;
+}
+function generateValidationLogic(model, dataParam = "_data", contextParam = "_context") {
+  if (!model.attributes) return "// No validation rules defined";
+  const validations = [];
+  const attrList = Array.isArray(model.attributes) ? model.attributes.map((a) => [a.name, a]) : Object.entries(model.attributes);
+  const AUTO_FIELDS = /* @__PURE__ */ new Set(["id", "createdAt", "updatedAt", "created_at", "updated_at", "createdBy", "updatedBy"]);
+  attrList.forEach(([name, attr]) => {
+    if (attr.required && !attr.auto && !AUTO_FIELDS.has(name)) {
+      validations.push(`
+    // ${name} is required
+    if (${contextParam}.operation === 'create' && !${dataParam}.${name}) {
+      errors.push('${name} is required');
+    }`);
+    }
+    if (attr.type === "String" || attr.type === "string") {
+      if (attr.min) {
+        validations.push(`
+    if (${dataParam}.${name} && ${dataParam}.${name}.length < ${attr.min}) {
+      errors.push('${name} must be at least ${attr.min} characters');
+    }`);
+      }
+      if (attr.max) {
+        validations.push(`
+    if (${dataParam}.${name} && ${dataParam}.${name}.length > ${attr.max}) {
+      errors.push('${name} must be at most ${attr.max} characters');
+    }`);
+      }
+    }
+    if (attr.values && Array.isArray(attr.values)) {
+      const values = attr.values.map((v) => `'${v}'`).join(", ");
+      validations.push(`
+    if (${dataParam}.${name} && ![${values}].includes(${dataParam}.${name})) {
+      errors.push('${name} must be one of: ${attr.values.join(", ")}');
+    }`);
+    }
+    if (attr.format === "email") {
+      validations.push(`
+    if (${dataParam}.${name} && !/^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/.test(${dataParam}.${name})) {
+      errors.push('${name} must be a valid email address');
+    }`);
+    }
+  });
+  return validations.join("\n") || "// No validation rules defined";
+}
+function generateCreateMethod(model, modelName, modelVar, controller, allModels) {
+  const hasEvents = controller.publishes && Array.isArray(controller.publishes);
+  const createEvent = hasEvents ? controller.publishes.find((e) => e.includes("Created")) : null;
+  return `
+  /**
+   * Create a new ${modelName}
+   */
+  public async create(data: any): Promise<any> {
+    // Validate input
+    const validationResult = this.validate(data, { operation: 'create' });
+    if (!validationResult.valid) {
+      throw new Error(\`Validation failed: \${validationResult.errors.join(', ')}\`);
+    }
+
+    // Transform FK fields to Prisma connect format
+    const prismaData = { ...data };
+    ${generateFKTransform(model, "prismaData", allModels)}
+
+    // Create record
+    const ${modelVar} = await prisma.${modelVar}.create({
+      data: prismaData${generateIncludeRelationships(model)}
+    });
+
+    ${createEvent ? `
+    // Publish event
+    eventBus.publish(EventName.${createEvent}, {
+      ${modelVar},
+      timestamp: new Date().toISOString()
+    });
+    ` : ""}
+
+    return ${modelVar};
+  }
+`;
+}
+function generateRetrieveMethod(model, modelName, modelVar) {
+  return `
+  /**
+   * Retrieve ${modelName} by ID
+   */
+  public async retrieve(id: string): Promise<any> {
+    const ${modelVar} = await prisma.${modelVar}.findUnique({
+      where: { id: parseId(id) }${generateIncludeRelationships(model)}
+    });
+
+    if (!${modelVar}) {
+      throw new Error('${modelName} not found');
+    }
+
+    return ${modelVar};
+  }
+
+  /**
+   * Retrieve all ${modelName}s
+   */
+  public async retrieveAll(options: { skip?: number; take?: number } = {}): Promise<any[]> {
+    return await prisma.${modelVar}.findMany({
+      skip: options.skip,
+      take: options.take${generateIncludeRelationships(model)}
+    });
+  }
+`;
+}
+function generateUpdateMethod(model, modelName, modelVar, controller, allModels) {
+  const hasEvents = controller.publishes && Array.isArray(controller.publishes);
+  const updateEvent = hasEvents ? controller.publishes.find((e) => e.includes("Updated")) : null;
+  return `
+  /**
+   * Update ${modelName}
+   */
+  public async update(id: string, data: any): Promise<any> {
+    // Validate input
+    const validationResult = this.validate(data, { operation: 'update' });
+    if (!validationResult.valid) {
+      throw new Error(\`Validation failed: \${validationResult.errors.join(', ')}\`);
+    }
+
+    // Strip nested relations and id \u2014 only send scalar fields to Prisma
+    const updateData: any = {};
+    for (const [key, value] of Object.entries(data)) {
+      if (key === 'id') continue;
+      if (Array.isArray(value)) continue;
+      if (value !== null && typeof value === 'object' && !(value instanceof Date)) continue;
+      updateData[key] = value;
+    }
+
+    // Transform FK fields to Prisma connect format
+    ${generateFKTransform(model, "updateData", allModels)}
+
+    // Update record
+    const ${modelVar} = await prisma.${modelVar}.update({
+      where: { id: parseId(id) },
+      data: updateData${generateIncludeRelationships(model)}
+    });
+
+    ${updateEvent ? `
+    // Publish event
+    eventBus.publish(EventName.${updateEvent}, {
+      ${modelVar},
+      timestamp: new Date().toISOString()
+    });
+    ` : ""}
+
+    return ${modelVar};
+  }
+`;
+}
+function generateEvolveMethod(model, modelName, modelVar, controller) {
+  const lifecycles = Array.isArray(model.lifecycles) ? model.lifecycles : model.lifecycles ? Object.entries(model.lifecycles).map(([name, lc]) => ({ name, ...lc })) : [];
+  const lifecycle = lifecycles[0];
+  const lifecycleName = lifecycle?.name || "status";
+  const states = lifecycle?.states || [];
+  const validTransitions = {};
+  if (states.length > 1) {
+    for (let i = 0; i < states.length - 1; i++) {
+      validTransitions[states[i]] = [states[i + 1]];
+    }
+  }
+  if (lifecycle?.transitions) {
+    const transitions = Array.isArray(lifecycle.transitions) ? lifecycle.transitions : Object.entries(lifecycle.transitions).map(([name, t]) => ({ 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);
+      }
+    }
+  }
+  return `
+  /**
+   * Evolve ${modelName} through lifecycle
+   * States: ${states.join(" \u2192 ")}
+   */
+  public async evolve(id: string, data: any): Promise<any> {
+    // Validate input
+    const validationResult = this.validate(data, { operation: 'evolve' });
+    if (!validationResult.valid) {
+      throw new Error(\`Validation failed: \${validationResult.errors.join(', ')}\`);
+    }
+
+    // Get current record to check lifecycle state
+    const current = await prisma.${modelVar}.findUnique({ where: { id: parseId(id) } });
+    if (!current) {
+      throw new Error('${modelName} not found');
+    }
+
+    ${states.length > 0 ? `
+    // Validate lifecycle transition
+    const currentState = (current as any).${lifecycleName};
+    const newState = data.${lifecycleName};
+    if (newState) {
+      const validTransitions: Record<string, string[]> = ${JSON.stringify(validTransitions)};
+      const allowed = validTransitions[currentState] || [];
+      if (!allowed.includes(newState)) {
+        throw new Error(\`Invalid transition: \${currentState} \u2192 \${newState}. Allowed: \${allowed.join(', ') || 'none'}\`);
+      }
+    }
+    ` : ""}
+
+    // Update record
+    const ${modelVar} = await prisma.${modelVar}.update({
+      where: { id: parseId(id) },
+      data${generateIncludeRelationships(model)}
+    });
+
+    return ${modelVar};
+  }
+`;
+}
+function generateDeleteMethod(model, modelName, modelVar, controller) {
+  const hasEvents = controller.publishes && Array.isArray(controller.publishes);
+  const deleteEvent = hasEvents ? controller.publishes.find((e) => e.includes("Deleted")) : null;
+  return `
+  /**
+   * Delete ${modelName}
+   */
+  public async delete(id: string): Promise<void> {
+    ${deleteEvent ? `
+    // Get record before deletion for event
+    const ${modelVar} = await prisma.${modelVar}.findUnique({ where: { id: parseId(id) } });
+    ` : ""}
+
+    await prisma.${modelVar}.delete({
+      where: { id: parseId(id) }
+    });
+
+    ${deleteEvent ? `
+    // Publish event
+    if (${modelVar}) {
+      eventBus.publish(EventName.${deleteEvent}, {
+        ${modelVar},
+        timestamp: new Date().toISOString()
+      });
+    }
+    ` : ""}
+  }
+`;
+}
+function generateCustomActions(controller, modelName, modelVar) {
+  if (!controller.actions || Object.keys(controller.actions).length === 0) {
+    return "";
+  }
+  const actions = [];
+  Object.entries(controller.actions).forEach(([actionName, action]) => {
+    actions.push(`
+  /**
+   * ${actionName}
+   * ${action.description || ""}
+   */
+  public async ${actionName}(${generateActionParams(action)}): Promise<any> {
+    // TODO: Implement ${actionName} logic
+    throw new Error('${actionName} not implemented');
+  }`);
+  });
+  return actions.join("\n");
+}
+function generateActionParams(action) {
+  if (!action.parameters || Object.keys(action.parameters).length === 0) {
+    return "";
+  }
+  const params = Object.entries(action.parameters).map(([name, param]) => {
+    const optional = !param.required;
+    return `${name}${optional ? "?" : ""}: ${mapTypeToTypeScript(param.type)}`;
+  });
+  return params.join(", ");
+}
+function mapTypeToTypeScript(type) {
+  const typeMap = {
+    String: "string",
+    Integer: "number",
+    Float: "number",
+    Boolean: "boolean",
+    Date: "Date",
+    DateTime: "Date",
+    UUID: "string",
+    JSON: "any"
+  };
+  return typeMap[type] || "any";
+}
+function generateFKTransform(model, varName = "prismaData", allModels) {
+  const rels = Array.isArray(model.relationships) ? model.relationships : Object.values(model.relationships || {});
+  const belongsToRels = rels.filter((r) => r.type === "belongsTo");
+  if (belongsToRels.length === 0) return "";
+  return belongsToRels.map((rel) => {
+    const relName = rel.name;
+    const fkField = `${relName}Id`;
+    let parseExpr = `${varName}.${fkField}`;
+    if (allModels) {
+      const targetModel = allModels.find((m) => m.name === rel.target);
+      if (targetModel) {
+        const idAttr = (Array.isArray(targetModel.attributes) ? targetModel.attributes : Object.values(targetModel.attributes || {})).find((a) => a.name === "id");
+        const idType = idAttr?.type || "String";
+        if (idType === "Integer" || idType === "Int" || idType === "Number") {
+          parseExpr = `parseInt(${varName}.${fkField}, 10)`;
+        }
+      }
+    }
+    return `if (${varName}.${fkField}) {
+      ${varName}.${relName} = { connect: { id: ${parseExpr} } };
+      delete ${varName}.${fkField};
+    }`;
+  }).join("\n    ");
+}
+function generateIncludeRelationships(model) {
+  if (!model.relationships) {
+    return "";
+  }
+  let relationshipKeys;
+  if (Array.isArray(model.relationships)) {
+    relationshipKeys = model.relationships.map((rel) => {
+      if (typeof rel === "string") {
+        return rel;
+      } else if (typeof rel === "object" && rel.name) {
+        return rel.name;
+      } else {
+        return null;
+      }
+    }).filter((rel) => rel !== null);
+  } else if (typeof model.relationships === "object") {
+    relationshipKeys = Object.keys(model.relationships);
+  } else {
+    return "";
+  }
+  if (relationshipKeys.length === 0) {
+    return "";
+  }
+  const includes = relationshipKeys.map((rel) => `        ${rel}: true`).join(",\n");
+  return `,
+      include: {
+${includes}
+      }`;
+}
+function hasEventPublishing(curedOps, controller) {
+  return controller.publishes && Array.isArray(controller.publishes) && controller.publishes.length > 0;
+}
+export {
+  generatePrismaController as default
+};

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

@@ -0,0 +1,243 @@
+import { generateBehaviorWithHelpers } from "./behavior-generator.js";
+function generatePrismaService(context) {
+  const { service, spec } = context;
+  if (!service) {
+    throw new Error("Service is required in template context");
+  }
+  const serviceName = service.name;
+  const hasEvents = service.publishes && service.publishes.length > 0 || service.subscribes && service.subscribes.length > 0;
+  return `/**
+ * ${serviceName}
+ * Abstract business logic service
+ * ${service.description || ""}
+ */
+
+import { PrismaClient } from '@prisma/client';
+${hasEvents ? `import { eventBus, EventName } from '../events/eventBus.js';` : ""}
+
+const prisma = new PrismaClient();
+
+/**
+ * ${serviceName} class
+ */
+export class ${serviceName} {
+  ${generateConstructor(service)}
+  ${generateOperationsWithHelpers(service)}
+  ${generateEventSubscriptions(service)}
+}
+
+// Export singleton instance
+export const ${serviceName.charAt(0).toLowerCase() + serviceName.slice(1)} = new ${serviceName}();
+export default ${serviceName.charAt(0).toLowerCase() + serviceName.slice(1)};
+`;
+}
+function generateConstructor(service) {
+  const hasSubscriptions = service.subscribes && service.subscribes.length > 0;
+  if (!hasSubscriptions) {
+    return "";
+  }
+  return `
+  private unsubscribers: Array<() => void> = [];
+
+  constructor() {
+    // Subscribe to events
+    this.setupEventSubscriptions();
+  }
+
+  /**
+   * Setup event subscriptions
+   */
+  private setupEventSubscriptions(): void {
+    ${service.subscribes.map((eventName) => `
+    // Subscribe to ${eventName}
+    const unsubscribe${eventName} = eventBus.subscribe(
+      EventName.${eventName},
+      this.on${eventName}.bind(this)
+    );
+    this.unsubscribers.push(unsubscribe${eventName});
+    `).join("\n")}
+  }
+
+  /**
+   * Cleanup subscriptions
+   */
+  public destroy(): void {
+    this.unsubscribers.forEach(unsubscribe => unsubscribe());
+    this.unsubscribers = [];
+  }
+`;
+}
+function generateOperationsWithHelpers(service) {
+  const ops = generateOperations(service);
+  if (_collectedHelpers.length > 0) {
+    const helpers = [...new Set(_collectedHelpers)].join("\n");
+    _collectedHelpers.length = 0;
+    return ops + "\n" + helpers;
+  }
+  return ops;
+}
+const _collectedHelpers = [];
+function generateOperations(service) {
+  if (!service.operations || Array.isArray(service.operations) && service.operations.length === 0 || !Array.isArray(service.operations) && Object.keys(service.operations).length === 0) {
+    return `
+  /**
+   * Execute service logic
+   */
+  public async execute(params: any): Promise<any> {
+    // TODO: Implement service logic
+    throw new Error('Service logic not implemented');
+  }
+`;
+  }
+  const entries = Array.isArray(service.operations) ? service.operations.map((op) => [op.name, op]) : Object.entries(service.operations);
+  const operations = [];
+  entries.forEach(([operationName, operation]) => {
+    operations.push(generateOperation(operationName, operation, service));
+  });
+  return operations.join("\n");
+}
+function generateOperation(operationName, operation, service) {
+  const params = generateOperationParams(operation);
+  const hasPublish = service.publishes && service.publishes.length > 0;
+  return `
+  /**
+   * ${operationName}
+   * ${operation.description || ""}
+   */
+  public async ${operationName}(${params}): Promise<any> {
+    try {
+      ${generateOperationLogic(operation, service)}
+
+      ${hasPublish ? `
+      // Publish event (example)
+      // eventBus.publish(EventName.SomeEvent, {
+      //   operation: '${operationName}',
+      //   timestamp: new Date().toISOString()
+      // });
+      ` : ""}
+
+      // Return result
+      return { success: true };
+    } catch (error) {
+      console.error(\`[${service.name}] ${operationName} failed:\`, error);
+      throw error;
+    }
+  }
+`;
+}
+function generateOperationParams(operation) {
+  if (!operation.parameters || Object.keys(operation.parameters).length === 0) {
+    return "params: any = {}";
+  }
+  const params = Object.entries(operation.parameters).map(([name, param]) => {
+    const optional = !param.required;
+    return `${name}${optional ? "?" : ""}: ${mapTypeToTypeScript(param.type)}`;
+  });
+  return params.join(", ");
+}
+function generateOperationLogic(operation, service) {
+  const impl = operation.implementation || {};
+  const meta = operation.metadata;
+  if (!impl.preconditions && operation.requires) {
+    impl.preconditions = Array.isArray(operation.requires) ? operation.requires : [operation.requires];
+  }
+  if (!impl.postconditions && operation.ensures) {
+    impl.postconditions = Array.isArray(operation.ensures) ? operation.ensures : [operation.ensures];
+  }
+  if (!impl.sideEffects && operation.publishes) {
+    impl.sideEffects = (Array.isArray(operation.publishes) ? operation.publishes : [operation.publishes]).map((e) => `Publish event: ${e}`);
+  }
+  if (impl.preconditions?.length || impl.postconditions?.length || impl.steps?.length || impl.transactional) {
+    const modelName = inferModelFromServiceName(service.name);
+    const context = {
+      modelName,
+      serviceName: service.name,
+      operationName: operation.name || "execute",
+      prismaModel: modelName
+    };
+    const behavior = {
+      preconditions: impl.preconditions || [],
+      postconditions: impl.postconditions || [],
+      sideEffects: impl.sideEffects || [],
+      steps: impl.steps || [],
+      transactional: impl.transactional || false
+    };
+    const opMeta = {
+      async: meta?.async ?? true,
+      cacheable: meta?.cacheable ?? false,
+      idempotent: meta?.idempotent ?? false
+    };
+    const result = generateBehaviorWithHelpers(behavior, opMeta, context);
+    _collectedHelpers.push(...result.helperMethods);
+    return result.body;
+  }
+  if (operation.description) {
+    return `// ${operation.description}`;
+  }
+  return `// TODO: Implement operation logic`;
+}
+function inferModelFromServiceName(serviceName) {
+  return serviceName.replace(/RelationshipService$/, "").replace(/Service$/, "") || "Entity";
+}
+function generateEventSubscriptions(service) {
+  if (!service.subscribes || service.subscribes.length === 0) {
+    return "";
+  }
+  const handlers = [];
+  service.subscribes.forEach((eventName) => {
+    handlers.push(`
+  /**
+   * Handle ${eventName} event
+   */
+  private async on${eventName}(payload: any): Promise<void> {
+    try {
+      console.log(\`[${service.name}] Received ${eventName} event\`, payload);
+
+      // TODO: Implement event handling logic
+      ${generateEventHandlerLogic(eventName, service)}
+
+      console.log(\`[${service.name}] ${eventName} event processed successfully\`);
+    } catch (error) {
+      console.error(\`[${service.name}] Failed to process ${eventName} event\`, error);
+      // TODO: Add error handling (retry, dead letter queue, etc.)
+    }
+  }`);
+  });
+  return handlers.join("\n");
+}
+function generateEventHandlerLogic(eventName, service) {
+  return `
+      // Example: Update related records
+      // await prisma.someModel.update({
+      //   where: { id: payload.id },
+      //   data: { ... }
+      // });
+
+      // Example: Trigger workflows
+      // await this.triggerWorkflow(payload);
+
+      // Example: Publish follow-up events
+      // eventBus.publish(EventName.AnotherEvent, {
+      //   original: payload,
+      //   processed: true
+      // });
+  `;
+}
+function mapTypeToTypeScript(type) {
+  const typeMap = {
+    String: "string",
+    Integer: "number",
+    Float: "number",
+    Boolean: "boolean",
+    Date: "Date",
+    DateTime: "Date",
+    UUID: "string",
+    JSON: "any",
+    Array: "any[]",
+    Object: "Record<string, any>"
+  };
+  return typeMap[type] || "any";
+}
+export {
+  generatePrismaService as default
+};