@specverse/engines 4.1.5 → 4.1.7

package/dist/libs/instance-factories/communication/templates/eventemitter/bus-generator.js

@@ -0,0 +1,83 @@
+function generateEventBus(context) {
+  const { spec } = context;
+  const events = spec.events ? Object.keys(spec.events) : [];
+  return `/**
+ * Event Bus
+ * In-memory event bus using EventEmitter3
+ * Generated from SpecVerse specification
+ */
+
+import EventEmitter from 'eventemitter3';
+
+// Event type definitions
+${events.map((event) => `export type ${event}Payload = any; // TODO: Define payload type`).join("\n")}
+
+// Event names enum
+export enum EventName {
+${events.map((event) => `  ${event} = '${event}',`).join("\n")}
+}
+
+/**
+ * Event Bus Singleton
+ */
+class EventBus extends EventEmitter {
+  private static instance: EventBus;
+
+  private constructor() {
+    super();
+    this.setMaxListeners(100); // Configure max listeners
+  }
+
+  /**
+   * Get singleton instance
+   */
+  public static getInstance(): EventBus {
+    if (!EventBus.instance) {
+      EventBus.instance = new EventBus();
+    }
+    return EventBus.instance;
+  }
+
+  /**
+   * Publish an event
+   */
+  public publish<T = any>(event: EventName | string, payload: T): void {
+    console.log(\`[EventBus] Publishing event: \${event}\`, payload);
+    this.emit(event, payload);
+  }
+
+  /**
+   * Subscribe to an event
+   */
+  public subscribe<T = any>(
+    event: EventName | string,
+    handler: (payload: T) => void | Promise<void>
+  ): () => void {
+    console.log(\`[EventBus] Subscribing to event: \${event}\`);
+    this.on(event, handler);
+
+    // Return unsubscribe function
+    return () => {
+      this.off(event, handler);
+    };
+  }
+
+  /**
+   * Subscribe to an event (one-time)
+   */
+  public subscribeOnce<T = any>(
+    event: EventName | string,
+    handler: (payload: T) => void | Promise<void>
+  ): void {
+    this.once(event, handler);
+  }
+}
+
+// Export singleton instance
+export const eventBus = EventBus.getInstance();
+export default eventBus;
+`;
+}
+export {
+  generateEventBus as default
+};

package/dist/libs/instance-factories/communication/templates/eventemitter/publisher-generator.js

@@ -0,0 +1,91 @@
+function generateEventPublisher(context) {
+  const { event, spec } = context;
+  if (!event) {
+    throw new Error("Event is required in template context");
+  }
+  const eventName = event.name;
+  const publisherName = `${eventName}Publisher`;
+  return `/**
+ * ${publisherName}
+ * Publisher for ${eventName} events
+ * ${event.description || ""}
+ */
+
+import { eventBus, EventName } from '../eventBus.js';
+
+export interface ${eventName}Payload {
+${generatePayloadInterface(event)}
+}
+
+/**
+ * ${publisherName} class
+ */
+export class ${publisherName} {
+  /**
+   * Publish ${eventName} event
+   */
+  public async publish(payload: ${eventName}Payload): Promise<void> {
+    try {
+      // Validate payload
+      this.validate(payload);
+
+      // Add timestamp if not present
+      const enrichedPayload = {
+        ...payload,
+        timestamp: payload.timestamp || new Date().toISOString(),
+      };
+
+      // Publish event
+      eventBus.publish(EventName.${eventName}, enrichedPayload);
+
+      console.log(\`[${publisherName}] Published event\`, enrichedPayload);
+    } catch (error) {
+      console.error(\`[${publisherName}] Failed to publish event\`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Validate event payload
+   */
+  private validate(payload: ${eventName}Payload): void {
+    // TODO: Add validation logic
+${generateValidation(event)}
+  }
+}
+
+// Export singleton instance
+export const ${eventName.toLowerCase()}Publisher = new ${publisherName}();
+export default ${eventName.toLowerCase()}Publisher;
+`;
+}
+function generatePayloadInterface(event) {
+  const attributes = event.attributes || {};
+  const fields = [];
+  for (const [name, config] of Object.entries(attributes)) {
+    const attr = config;
+    const type = attr.type || "String";
+    let tsType = "string";
+    if (type === "Integer" || type === "Number") tsType = "number";
+    if (type === "Boolean") tsType = "boolean";
+    if (type === "DateTime") tsType = "string";
+    if (type === "UUID") tsType = "string";
+    const optional = attr.required ? "" : "?";
+    fields.push(`  ${name}${optional}: ${tsType};`);
+  }
+  return fields.join("\n") || "  // No attributes defined";
+}
+function generateValidation(event) {
+  const attributes = event.attributes || {};
+  const validations = [];
+  for (const [name, config] of Object.entries(attributes)) {
+    const attr = config;
+    if (attr.required) {
+      validations.push(`    if (!payload.${name}) throw new Error('${name} is required');`);
+    }
+  }
+  return validations.join("\n") || "    // No validation rules";
+}
+export {
+  generateEventPublisher as default
+};

package/dist/libs/instance-factories/communication/templates/eventemitter/subscriber-generator.js

@@ -0,0 +1,86 @@
+function generateEventSubscriber(context) {
+  const { event, service, spec } = context;
+  if (!event) {
+    throw new Error("Event is required in template context");
+  }
+  const eventName = event.name;
+  const subscriberName = `${eventName}Subscriber`;
+  return `/**
+ * ${subscriberName}
+ * Subscriber for ${eventName} events
+ * ${event.description || ""}
+ */
+
+import { eventBus, EventName, type ${eventName}Payload } from '../eventBus.js';
+
+/**
+ * ${subscriberName} class
+ */
+export class ${subscriberName} {
+  private unsubscribe?: () => void;
+
+  /**
+   * Start listening for ${eventName} events
+   */
+  public start(): void {
+    console.log(\`[${subscriberName}] Starting subscriber\`);
+
+    this.unsubscribe = eventBus.subscribe<${eventName}Payload>(
+      EventName.${eventName},
+      this.handleEvent.bind(this)
+    );
+  }
+
+  /**
+   * Stop listening for ${eventName} events
+   */
+  public stop(): void {
+    if (this.unsubscribe) {
+      console.log(\`[${subscriberName}] Stopping subscriber\`);
+      this.unsubscribe();
+      this.unsubscribe = undefined;
+    }
+  }
+
+  /**
+   * Handle ${eventName} event
+   */
+  private async handleEvent(payload: ${eventName}Payload): Promise<void> {
+    try {
+      console.log(\`[${subscriberName}] Received event\`, payload);
+
+      // Process event
+      await this.processEvent(payload);
+
+      console.log(\`[${subscriberName}] Event processed successfully\`);
+    } catch (error) {
+      console.error(\`[${subscriberName}] Failed to process event\`, error);
+      // TODO: Add error handling (dead letter queue, retry logic, etc.)
+    }
+  }
+
+  /**
+   * Process ${eventName} event
+   */
+  private async processEvent(payload: ${eventName}Payload): Promise<void> {
+    // TODO: Implement event processing logic
+    ${generateProcessingLogic(event)}
+  }
+}
+
+// Export singleton instance
+export const ${eventName.toLowerCase()}Subscriber = new ${subscriberName}();
+export default ${eventName.toLowerCase()}Subscriber;
+`;
+}
+function generateProcessingLogic(event) {
+  return `
+    // Example: Update database, send notifications, trigger workflows, etc.
+    console.log('Processing ${event.name} event:', payload);
+
+    // Add your business logic here
+  `;
+}
+export {
+  generateEventSubscriber as default
+};

package/dist/libs/instance-factories/controllers/templates/fastify/meta-routes-generator.js

@@ -0,0 +1,93 @@
+function generateMetaRoutes(context) {
+  const { spec } = context;
+  return `/**
+ * Meta API Routes
+ *
+ * Provides spec and view metadata endpoints for the frontend
+ */
+
+import { FastifyInstance, FastifyPluginOptions } from 'fastify';
+import { readFile } from 'fs/promises';
+import { join } from 'path';
+import { parse } from 'yaml';
+
+export default async function MetaRoutes(
+  fastify: FastifyInstance,
+  options: FastifyPluginOptions
+) {
+  // Get specification
+  fastify.get('/spec', async (request, reply) => {
+    try {
+      const specPath = join(process.cwd(), '../../../specs/main.specly');
+      const specContent = await readFile(specPath, 'utf-8');
+      const spec = parse(specContent);
+      return spec;
+    } catch (error: any) {
+      reply.status(500).send({ error: \`Failed to load spec: \${error.message}\` });
+    }
+  });
+
+  // Get all views
+  fastify.get('/views', async (request, reply) => {
+    try {
+      const specPath = join(process.cwd(), '../../../specs/main.specly');
+      const specContent = await readFile(specPath, 'utf-8');
+      const spec = parse(specContent);
+
+      // Extract views from the spec
+      const views = [];
+      if (spec.components && typeof spec.components === 'object') {
+        // components is an object with component names as keys
+        for (const [componentName, component] of Object.entries(spec.components)) {
+          if (component && typeof component === 'object' && 'views' in component) {
+            const componentViews = component.views as Record<string, any>;
+            for (const [viewName, viewDef] of Object.entries(componentViews)) {
+              views.push({
+                name: viewName,
+                ...viewDef as any
+              });
+            }
+          }
+        }
+      }
+
+      return { views };
+    } catch (error: any) {
+      reply.status(500).send({ error: \`Failed to load views: \${error.message}\` });
+    }
+  });
+
+  // Get individual view by name
+  fastify.get('/views/:viewName', async (request, reply) => {
+    try {
+      const { viewName } = request.params as { viewName: string };
+      const specPath = join(process.cwd(), '../../../specs/main.specly');
+      const specContent = await readFile(specPath, 'utf-8');
+      const spec = parse(specContent);
+
+      // Find the view
+      if (spec.components && typeof spec.components === 'object') {
+        for (const [componentName, component] of Object.entries(spec.components)) {
+          if (component && typeof component === 'object' && 'views' in component) {
+            const componentViews = component.views as Record<string, any>;
+            if (componentViews[viewName]) {
+              return {
+                name: viewName,
+                ...componentViews[viewName]
+              };
+            }
+          }
+        }
+      }
+
+      reply.status(404).send({ error: \`View \${viewName} not found\` });
+    } catch (error: any) {
+      reply.status(500).send({ error: \`Failed to load view: \${error.message}\` });
+    }
+  });
+}
+`;
+}
+export {
+  generateMetaRoutes as default
+};

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

@@ -0,0 +1,280 @@
+function generateFastifyRoutes(context) {
+  const { controller, model, spec, implType } = context;
+  if (!controller) {
+    throw new Error("Controller is required in template context");
+  }
+  const modelName = model?.name || controller.modelReference;
+  const controllerName = controller.name;
+  const routeName = controllerName || `${modelName}Controller`;
+  const isModelController = !!modelName;
+  const handlerName = isModelController ? `${modelName}Controller` : controllerName;
+  const imports = generateImports(controller, modelName, handlerName, isModelController, implType);
+  let endpoints = controller.endpoints;
+  if (!endpoints || endpoints.length === 0) {
+    if (controller.cured) {
+      endpoints = curedToEndpoints(controller.cured, modelName);
+    }
+  }
+  if (!endpoints || endpoints.length === 0) {
+    console.warn(`Warning: Controller ${controllerName} has no endpoints. Generating empty routes file.`);
+  }
+  const routeHandlers = endpoints?.map((endpoint) => {
+    return generateRouteHandler(endpoint, modelName, handlerName, isModelController, implType, controllerName);
+  }).join("\n\n") || "";
+  return `${imports}
+
+/**
+ * ${routeName} Routes
+ * Generated from SpecVerse specification
+ *
+ * ${isModelController ? `Model: ${modelName}` : `Service: ${controllerName}`}
+ * Operations: ${controller.endpoints?.map((e) => e.operation).join(", ") || "CURED"}
+ */
+export default async function ${routeName.replace("Controller", "")}Routes(
+  fastify: FastifyInstance,
+  options: any
+) {
+  const handler = ${isModelController ? "options.controllers" : "options.services"}.${handlerName};
+
+${routeHandlers.split("\n").map((line) => "  " + line).join("\n")}
+}
+`;
+}
+function generateImports(controller, modelName, handlerName, isModelController, implType) {
+  const imports = [
+    `import { FastifyInstance, FastifyRequest, FastifyReply } from 'fastify';`
+  ];
+  if (implType?.technology?.validation === "zod" && modelName) {
+    imports.push(`import { ${modelName}Schema } from '../validation/${modelName}.schema.js';`);
+  }
+  return imports.join("\n");
+}
+function generateRouteHandler(endpoint, modelName, handlerName, isModelController, implType, controllerName) {
+  let operation = endpoint.operation || endpoint.name;
+  if (!operation || operation === "custom") {
+    const serviceOp = endpoint.serviceOperation?.type;
+    if (serviceOp === "custom" && endpoint.path) {
+      const pathParts = endpoint.path.split("/").filter((p) => p);
+      const lastPart = pathParts[pathParts.length - 1];
+      operation = lastPart.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+    } else if (!operation) {
+      operation = serviceOp;
+    }
+  }
+  if (!operation) {
+    operation = inferOperationFromMethodAndPath(endpoint.method, endpoint.path);
+  }
+  if (!operation || operation === "unknown") {
+    console.warn(`Warning: Could not determine operation for endpoint in ${controllerName || "controller"}. Endpoint data:`, {
+      operation: endpoint.operation,
+      name: endpoint.name,
+      method: endpoint.method,
+      path: endpoint.path,
+      serviceOperation: endpoint.serviceOperation
+    });
+  }
+  const method = endpoint.method?.toLowerCase() || inferHttpMethod(operation);
+  const path = inferPath(operation, endpoint);
+  const handler = generateHandlerBody(operation, modelName, handlerName, isModelController, implType);
+  let route = `// ${operation} ${modelName}
+`;
+  route += `fastify.${method}('${path}', {
+`;
+  if (implType?.technology?.validation === "zod") {
+    route += `  schema: {
+`;
+    if (operation === "create" || operation === "update" || operation === "evolve") {
+      route += `    body: ${modelName}Schema.${operation},
+`;
+    }
+    if (operation === "retrieve" || operation === "update" || operation === "delete") {
+      route += `    params: ${modelName}Schema.params,
+`;
+    }
+    route += `    response: {
+`;
+    route += `      200: ${modelName}Schema.response
+`;
+    route += `    }
+`;
+    route += `  },
+`;
+  }
+  const usesRequest = ["create", "retrieve", "update", "evolve", "delete", "validate"].includes(operation) || !["list"].includes(operation);
+  const requestParam = usesRequest ? "request" : "_request";
+  route += `  handler: async (${requestParam}: FastifyRequest, reply: FastifyReply) => {
+`;
+  route += handler.split("\n").map((line) => "    " + line).join("\n") + "\n";
+  route += `  }
+`;
+  route += `});`;
+  return route;
+}
+function generateHandlerBody(operation, modelName, handlerName, isModelController, implType) {
+  const rawLowerModel = modelName?.toLowerCase() || "item";
+  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 lowerModel = RESERVED_WORDS.has(rawLowerModel) ? `${rawLowerModel}Item` : rawLowerModel;
+  const operationMap = {
+    "custom": "create",
+    // POST without ID -> create
+    "findUnique": "retrieve",
+    // GET with ID -> retrieve
+    "findMany": "list",
+    // GET without ID -> list
+    "updateUnique": "update",
+    // PUT with ID -> update
+    "deleteUnique": "delete"
+    // DELETE with ID -> delete
+  };
+  const mappedOperation = operationMap[operation] || operation;
+  switch (mappedOperation) {
+    case "create":
+      return `try {
+  const ${lowerModel} = await handler.create(request.body as any);
+  return reply.status(201).send(${lowerModel});
+} catch (error) {
+  return reply.status(400).send({
+    error: 'Failed to create ${lowerModel}',
+    message: error instanceof Error ? error.message : String(error)
+  });
+}`;
+    case "retrieve":
+      return `try {
+  const { id } = request.params as { id: string };
+  const ${lowerModel} = await handler.retrieve(id);
+
+  if (!${lowerModel}) {
+    return reply.status(404).send({ error: '${modelName} not found' });
+  }
+
+  return reply.send(${lowerModel});
+} catch (error) {
+  return reply.status(500).send({
+    error: 'Failed to retrieve ${lowerModel}',
+    message: error instanceof Error ? error.message : String(error)
+  });
+}`;
+    case "update":
+    case "evolve":
+      return `try {
+  const { id } = request.params as { id: string };
+  const ${lowerModel} = await handler.${operation}(id, request.body as any);
+  return reply.send(${lowerModel});
+} catch (error) {
+  return reply.status(400).send({
+    error: 'Failed to ${operation} ${lowerModel}',
+    message: error instanceof Error ? error.message : String(error)
+  });
+}`;
+    case "delete":
+      return `try {
+  const { id } = request.params as { id: string };
+  await handler.delete(id);
+  return reply.status(204).send();
+} catch (error) {
+  return reply.status(500).send({
+    error: 'Failed to delete ${lowerModel}',
+    message: error instanceof Error ? error.message : String(error)
+  });
+}`;
+    case "list":
+      return `try {
+  const ${lowerModel}s = await handler.retrieveAll();
+  return reply.send(${lowerModel}s);
+} catch (error) {
+  return reply.status(500).send({
+    error: 'Failed to list ${lowerModel}s',
+    message: error instanceof Error ? error.message : String(error)
+  });
+}`;
+    case "validate":
+      return `try {
+  const { data, operation: op } = request.body as { data: any; operation: string };
+  const result = handler.validate(data, { operation: op });
+  return reply.send(result);
+} catch (error) {
+  return reply.status(400).send({
+    error: 'Validation failed',
+    message: error instanceof Error ? error.message : String(error)
+  });
+}`;
+    default:
+      return `try {
+  const result = await handler.${operation}(request.body as any);
+  return reply.send(result);
+} catch (error) {
+  return reply.status(400).send({
+    error: 'Failed to execute ${operation}',
+    message: error instanceof Error ? error.message : String(error)
+  });
+}`;
+  }
+}
+function inferOperationFromMethodAndPath(method, path) {
+  if (!method || !path) return "unknown";
+  const methodLower = method.toLowerCase();
+  const hasIdParam = path.includes(":id");
+  if (methodLower === "post" && !hasIdParam) return "create";
+  if (methodLower === "get" && hasIdParam) return "retrieve";
+  if (methodLower === "get" && !hasIdParam) return "list";
+  if (methodLower === "put" && hasIdParam) return "update";
+  if (methodLower === "patch" && hasIdParam) return "evolve";
+  if (methodLower === "delete" && hasIdParam) return "delete";
+  return "unknown";
+}
+function inferHttpMethod(operation) {
+  if (!operation) {
+    console.warn("Warning: undefined operation in inferHttpMethod");
+    return "post";
+  }
+  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";
+}
+function inferPath(operation, endpoint) {
+  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";
+  if (endpoint.path && endpoint.serviceOperation?.type === "custom") {
+    const pathParts = endpoint.path.split("/").filter((p) => p);
+    const lastPart = pathParts[pathParts.length - 1];
+    return `/${lastPart}`;
+  }
+  return `/${opLower}`;
+}
+function curedToEndpoints(cured, modelName) {
+  const endpoints = [];
+  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;
+}
+export {
+  generateFastifyRoutes as default
+};