@specverse/engines 4.1.4 → 4.1.6

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

@@ -0,0 +1,415 @@
+import { CONVENTION_PATTERNS } from "../shared-patterns.js";
+function generateInterpreterModule() {
+  const lines = [];
+  lines.push(`/**
+ * Generated Behavior Functions \u2014 targeting DynamicModelStore
+ *
+ * AUTO-GENERATED by realize engine memory factory.
+ * DO NOT EDIT \u2014 modify step-conventions-memory.ts instead.
+ *
+ * Convention count: ${CONVENTION_PATTERNS.length}
+ */
+
+import type { DynamicModelStore, Entity } from '../stores/dynamic-model-store.js';
+import type { EventBus } from './event-bus.js';
+
+export interface RuntimeContext {
+  modelName: string;
+  store: DynamicModelStore;
+  eventBus: EventBus;
+  entity?: Entity;
+  params: Record<string, any>;
+  operationName: string;
+}
+
+/** Resolve entity ID from params \u2014 tries id, modelId (e.g. pollId), entity */
+function resolveId(model: string, ctx: RuntimeContext): string | undefined {
+  const modelIdKey = model.charAt(0).toLowerCase() + model.slice(1) + 'Id';
+  return ctx.params.id || ctx.params[modelIdKey] || ctx.entity?.id;
+}
+
+export interface ConventionHandler {
+  name: string;
+  pattern: RegExp;
+  execute: (match: RegExpMatchArray, ctx: RuntimeContext) => Promise<any>;
+}
+
+export const GENERATED_CONVENTIONS: ConventionHandler[] = [
+`);
+  lines.push(generateValidate());
+  lines.push(generateCheckNoExisting());
+  lines.push(generateCheck());
+  lines.push(generateFind());
+  lines.push(generateFindAllFor());
+  lines.push(generateCountPer());
+  lines.push(generateCreate());
+  lines.push(generateUpdateField());
+  lines.push(generateUpdate());
+  lines.push(generateDelete());
+  lines.push(generateTransition());
+  lines.push(generateSet());
+  lines.push(generateIncrement());
+  lines.push(generateDecrement());
+  lines.push(generateCalculate());
+  lines.push(generateSendEvent());
+  lines.push(generateSendNotification());
+  lines.push(generateCallService());
+  lines.push(generateReturn());
+  lines.push(`];
+
+/**
+ * Match a step against conventions and execute.
+ * Returns { executed, skipped, result }.
+ */
+export async function executeStep(
+  step: string,
+  ctx: RuntimeContext
+): Promise<{ matched: boolean; convention?: string; result?: any; error?: string }> {
+  for (const convention of GENERATED_CONVENTIONS) {
+    const match = step.match(convention.pattern);
+    if (match) {
+      try {
+        const result = await convention.execute(match, ctx);
+        return { matched: true, convention: convention.name, result };
+      } catch (error: any) {
+        return { matched: true, convention: convention.name, error: error.message };
+      }
+    }
+  }
+  return { matched: false };
+}
+`);
+  return lines.join("\n");
+}
+function p(pattern) {
+  const src = CONVENTION_PATTERNS.find((p2) => p2.name === pattern)?.pattern.source || "";
+  const flags = CONVENTION_PATTERNS.find((p2) => p2.name === pattern)?.pattern.flags || "i";
+  return `/${src}/${flags}`;
+}
+function generateValidate() {
+  return `  {
+    name: 'validate',
+    pattern: ${p("validate")},
+    execute: async (m, ctx) => {
+      const target = m[1];
+      const data = ctx.params.data || ctx.params;
+      if (!data || Object.keys(data).length === 0) {
+        throw new Error(\`Validation failed: no data provided for \${target}\`);
+      }
+      return { valid: true, target };
+    },
+  },`;
+}
+function generateCheckNoExisting() {
+  return `  {
+    name: 'check-no-existing',
+    pattern: ${p("check-no-existing")},
+    execute: async (m, ctx) => {
+      const checkModel = m[1].charAt(0).toUpperCase() + m[1].slice(1);
+      const entityA = m[2].charAt(0).toUpperCase() + m[2].slice(1);
+      const entityB = m[3].charAt(0).toUpperCase() + m[3].slice(1);
+      const fkA = entityA.charAt(0).toLowerCase() + entityA.slice(1) + 'Id';
+      const fkB = entityB.charAt(0).toLowerCase() + entityB.slice(1) + 'Id';
+      const idA = ctx.params[fkA] || resolveId(entityA, ctx);
+      const idB = ctx.params[fkB] || resolveId(entityB, ctx);
+      if (!idA || !idB) return true;
+      const all = await ctx.store.query(checkModel, {});
+      const existing = all.entities.find((e: any) =>
+        (e.data?.[fkA] === idA) && (e.data?.[fkB] === idB)
+      );
+      if (existing) {
+        throw new Error(\`\${entityA} already has a \${checkModel} for this \${entityB}\`);
+      }
+      return true;
+    },
+  },`;
+}
+function generateCheck() {
+  return `  {
+    name: 'check',
+    pattern: ${p("check")},
+    execute: async (m, ctx) => {
+      const condition = m[1];
+      if (ctx.entity) {
+        const data = ctx.entity.data || {};
+        const fieldMatch = condition.match(/(\\w+)/i);
+        if (fieldMatch && data[fieldMatch[1]] !== undefined) {
+          return !!data[fieldMatch[1]];
+        }
+      }
+      return true;
+    },
+  },`;
+}
+function generateFind() {
+  return `  {
+    name: 'find',
+    pattern: ${p("find")},
+    execute: async (m, ctx) => {
+      const model = m[1];
+      const field = m[2];
+      if (field === 'id') {
+        const id = resolveId(model, ctx);
+        if (!id) throw new Error(\`No id to find \${model}\`);
+        const entity = await ctx.store.retrieve(model, id);
+        if (!entity) throw new Error(\`\${model} not found by id: \${id}\`);
+        return entity;
+      }
+      const value = ctx.params[field] || ctx.params.data?.[field];
+      const result = await ctx.store.query(model, { filters: { [field]: value }, limit: 1 });
+      if (result.entities.length === 0) throw new Error(\`\${model} not found by \${field}: \${value}\`);
+      return result.entities[0];
+    },
+  },`;
+}
+function generateFindAllFor() {
+  return `  {
+    name: 'find-all-for',
+    pattern: ${p("find-all-for")},
+    execute: async (m, ctx) => {
+      const targetModel = m[1].charAt(0).toUpperCase() + m[1].slice(1);
+      const sourceModel = m[2].charAt(0).toUpperCase() + m[2].slice(1);
+      const sourceId = resolveId(sourceModel, ctx);
+      if (!sourceId) throw new Error(\`No id to find \${targetModel}s for \${sourceModel}\`);
+      const fk = sourceModel.charAt(0).toLowerCase() + sourceModel.slice(1) + 'Id';
+      const result = await ctx.store.query(targetModel, { filters: { [fk]: sourceId } });
+      if (result.entities.length === 0) {
+        const allResult = await ctx.store.query(targetModel, {});
+        return allResult.entities.filter((e: any) => e.data?.[fk] === sourceId);
+      }
+      return result.entities;
+    },
+  },`;
+}
+function generateCountPer() {
+  return `  {
+    name: 'count-per',
+    pattern: ${p("count-per")},
+    execute: async (m, ctx) => {
+      const countModel = m[1].charAt(0).toUpperCase() + m[1].slice(1);
+      const groupModel = m[2].charAt(0).toUpperCase() + m[2].slice(1);
+      const groupFk = groupModel.charAt(0).toLowerCase() + groupModel.slice(1) + 'Id';
+      const allResult = await ctx.store.query(countModel, {});
+      const counts: Record<string, number> = {};
+      for (const entity of allResult.entities) {
+        const groupKey = entity.data?.[groupFk] || 'unknown';
+        counts[groupKey] = (counts[groupKey] || 0) + 1;
+      }
+      return counts;
+    },
+  },`;
+}
+function generateCreate() {
+  return `  {
+    name: 'create',
+    pattern: ${p("create")},
+    execute: async (m, ctx) => {
+      const model = m[1];
+      const data = ctx.params.data || ctx.params;
+      return await ctx.store.create(model, data);
+    },
+  },`;
+}
+function generateUpdateField() {
+  return `  {
+    name: 'update-field',
+    pattern: ${p("update-field")},
+    execute: async (m, ctx) => {
+      const model = m[1];
+      const field = m[2];
+      let value: any = m[3].trim();
+      if (value === 'current time' || value === 'now') value = new Date().toISOString();
+      const id = resolveId(model, ctx);
+      if (!id) throw new Error(\`No id to update \${model}.\${field}\`);
+      // Check if field is a lifecycle \u2014 use evolveLifecycle (no data validation)
+      const entity = await ctx.store.retrieve(model, id);
+      if (entity?.metadata?.lifecycleStates && field in entity.metadata.lifecycleStates) {
+        return await ctx.store.evolveLifecycle(model, id, field, value);
+      }
+      return await ctx.store.update(model, id, { [field]: value });
+    },
+  },`;
+}
+function generateUpdate() {
+  return `  {
+    name: 'update',
+    pattern: ${p("update")},
+    execute: async (m, ctx) => {
+      const model = m[1];
+      const id = resolveId(model, ctx);
+      const data = ctx.params.data || ctx.params;
+      if (!id) throw new Error(\`No id to update \${model}\`);
+      return await ctx.store.update(model, id, data);
+    },
+  },`;
+}
+function generateDelete() {
+  return `  {
+    name: 'delete',
+    pattern: ${p("delete")},
+    execute: async (m, ctx) => {
+      const model = m[1];
+      const id = resolveId(model, ctx);
+      if (!id) throw new Error(\`No id to delete \${model}\`);
+      await ctx.store.delete(model, id);
+      return { deleted: true };
+    },
+  },`;
+}
+function generateTransition() {
+  return `  {
+    name: 'transition',
+    pattern: ${p("transition")},
+    execute: async (m, ctx) => {
+      const model = m[1];
+      const state = m[2];
+      const id = resolveId(model, ctx);
+      if (!id) throw new Error(\`No id to transition \${model}\`);
+      const entity = await ctx.store.retrieve(model, id);
+      if (!entity) throw new Error(\`\${model} not found for transition\`);
+      const lifecycleName = Object.keys(entity.metadata?.lifecycleStates || {})[0];
+      if (lifecycleName) {
+        return await ctx.store.evolveLifecycle(model, id, lifecycleName, state);
+      }
+      throw new Error(\`No lifecycle found on \${model} to transition\`);
+    },
+  },`;
+}
+function generateSet() {
+  return `  {
+    name: 'set',
+    pattern: ${p("set")},
+    execute: async (m, ctx) => {
+      const field = m[1];
+      let value: any = m[2].trim();
+      if (/current time|now|timestamp/i.test(value)) value = new Date().toISOString();
+      const id = resolveId(ctx.modelName, ctx);
+      if (!id) throw new Error(\`No id to set \${field}\`);
+      return await ctx.store.update(ctx.modelName, id, { [field]: value });
+    },
+  },`;
+}
+function generateIncrement() {
+  return `  {
+    name: 'increment',
+    pattern: ${p("increment")},
+    execute: async (m, ctx) => {
+      const field = m[1];
+      const amount = /^\\d+$/.test(m[2]) ? parseInt(m[2]) : (ctx.params[m[2]] || 1);
+      const id = resolveId(ctx.modelName, ctx);
+      if (!id) throw new Error(\`No id to increment \${field}\`);
+      const entity = await ctx.store.retrieve(ctx.modelName, id);
+      if (!entity) throw new Error(\`Entity not found to increment \${field}\`);
+      const current = (entity.data[field] || 0) as number;
+      return await ctx.store.update(ctx.modelName, id, { [field]: current + amount });
+    },
+  },`;
+}
+function generateDecrement() {
+  return `  {
+    name: 'decrement',
+    pattern: ${p("decrement")},
+    execute: async (m, ctx) => {
+      const field = m[1];
+      const amount = /^\\d+$/.test(m[2]) ? parseInt(m[2]) : (ctx.params[m[2]] || 1);
+      const id = resolveId(ctx.modelName, ctx);
+      if (!id) throw new Error(\`No id to decrement \${field}\`);
+      const entity = await ctx.store.retrieve(ctx.modelName, id);
+      if (!entity) throw new Error(\`Entity not found to decrement \${field}\`);
+      const current = (entity.data[field] || 0) as number;
+      if (current < amount) throw new Error(\`Cannot decrement \${field} below zero\`);
+      return await ctx.store.update(ctx.modelName, id, { [field]: current - amount });
+    },
+  },`;
+}
+function generateCalculate() {
+  return `  {
+    name: 'calculate',
+    pattern: ${p("calculate")},
+    execute: async (m, ctx) => {
+      const metric = m[1].toLowerCase();
+      if (metric.includes('percentage') || metric.includes('percent')) {
+        const counts = ctx.params._lastResult;
+        if (counts && typeof counts === 'object') {
+          const total = Object.values(counts as Record<string, number>).reduce((a: number, b: number) => a + b, 0);
+          if (total > 0) {
+            const pcts: Record<string, string> = {};
+            for (const [key, count] of Object.entries(counts as Record<string, number>)) {
+              pcts[key] = \`\${((count / total) * 100).toFixed(1)}%\`;
+            }
+            return pcts;
+          }
+        }
+      }
+      if (metric.includes('winner') || metric.includes('max') || metric.includes('highest')) {
+        const counts = ctx.params._lastResult;
+        if (counts && typeof counts === 'object') {
+          let maxKey = '', maxVal = -1;
+          for (const [key, val] of Object.entries(counts as Record<string, number>)) {
+            if (val > maxVal) { maxVal = val; maxKey = key; }
+          }
+          return { winner: maxKey, count: maxVal };
+        }
+      }
+      return 0;
+    },
+  },`;
+}
+function generateSendEvent() {
+  return `  {
+    name: 'send-event',
+    pattern: ${p("send-event")},
+    execute: async (m, ctx) => {
+      const event = m[1];
+      await ctx.eventBus.publish(event, {
+        modelName: ctx.modelName,
+        entityId: ctx.entity?.id || ctx.params.id,
+        operation: ctx.operationName,
+        timestamp: new Date().toISOString(),
+      });
+      return { event, published: true };
+    },
+  },`;
+}
+function generateSendNotification() {
+  return `  {
+    name: 'send-notification',
+    pattern: ${p("send-notification")},
+    execute: async (m, ctx) => {
+      const type = m[1];
+      await ctx.eventBus.publish(\`\${type}Notification\`, {
+        modelName: ctx.modelName,
+        entityId: ctx.entity?.id || ctx.params.id,
+        operation: ctx.operationName,
+      });
+      return { notification: type, sent: true };
+    },
+  },`;
+}
+function generateCallService() {
+  return `  {
+    name: 'call-service',
+    pattern: ${p("call-service")},
+    execute: async (m, ctx) => {
+      const service = m[1];
+      const method = m[2];
+      await ctx.eventBus.publish(\`\${service}.\${method}\`, ctx.params);
+      return { delegated: true, service, method };
+    },
+  },`;
+}
+function generateReturn() {
+  return `  {
+    name: 'return',
+    pattern: ${p("return")},
+    execute: async (m, ctx) => {
+      // Return the last computed result if available, otherwise entity or literal
+      if (ctx.params._lastResult !== undefined) return ctx.params._lastResult;
+      if (ctx.entity) return ctx.entity;
+      return { value: m[1].trim() };
+    },
+  },`;
+}
+export {
+  generateInterpreterModule
+};

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

@@ -0,0 +1,177 @@
+import { matchStep } from "./step-conventions.js";
+function generateBehaviorBody(behavior, opMeta, context) {
+  const result = generateBehaviorWithHelpers(behavior, opMeta, context);
+  return result.body;
+}
+function generateBehaviorWithHelpers(behavior, opMeta, context) {
+  const parts = [];
+  const helperMethods = [];
+  const preconditions = generatePreconditionChecks(
+    behavior.preconditions || [],
+    context
+  );
+  if (preconditions) parts.push(preconditions);
+  const { code, helpers } = generateStepLogic(
+    behavior.steps || [],
+    context
+  );
+  parts.push(code);
+  helperMethods.push(...helpers);
+  const postconditions = generatePostconditionVerification(
+    behavior.postconditions || []
+  );
+  if (postconditions) parts.push(postconditions);
+  const events = generateEventPublishing(
+    behavior.sideEffects || [],
+    context.operationName
+  );
+  if (events) parts.push(events);
+  let body = parts.join("\n\n");
+  if (behavior.transactional) {
+    body = generateTransactionWrapper(body, context);
+  }
+  return { body, helperMethods };
+}
+function generatePreconditionChecks(preconditions, context) {
+  if (preconditions.length === 0) return "";
+  const checks = preconditions.map((pc) => matchPreconditionPattern(pc, context));
+  return `    // === PRECONDITIONS ===
+${checks.join("\n")}`;
+}
+function matchPreconditionPattern(precondition, context) {
+  const pc = precondition.toLowerCase();
+  const prismaModel = context.prismaModel || context.modelName;
+  const existsMatch = precondition.match(/^(\w+)\s+exists/i);
+  if (existsMatch) {
+    const entity = existsMatch[1];
+    const entityVar = entity.charAt(0).toLowerCase() + entity.slice(1);
+    return `    // Guard: ${precondition}
+    const ${entityVar} = await prisma.${entityVar}.findUnique({ where: { id: params.id } });
+    if (!${entityVar}) {
+      throw new Error('Precondition failed: ${precondition}');
+    }`;
+  }
+  if (pc.includes("is not empty") || pc.includes("is required")) {
+    const fieldMatch = precondition.match(/^(\w+)\s+is/i);
+    if (fieldMatch) {
+      const field = fieldMatch[1];
+      return `    // Guard: ${precondition}
+    if (!params.${field}) {
+      throw new Error('Precondition failed: ${precondition}');
+    }`;
+    }
+  }
+  if (pc.includes("is valid")) {
+    return `    // Guard: ${precondition}
+    const validation = this.validate(params, { operation: '${context.operationName}' });
+    if (!validation.valid) {
+      throw new Error('Precondition failed: ${precondition} \u2014 ' + validation.errors.join(', '));
+    }`;
+  }
+  const matchesMatch = precondition.match(/^(\w+)\s+(?:matches|equals)\s+(.+)/i);
+  if (matchesMatch) {
+    const left = matchesMatch[1];
+    const right = matchesMatch[2];
+    return `    // Guard: ${precondition}
+    if (params.${left.charAt(0).toLowerCase() + left.slice(1)} !== params.${right.charAt(0).toLowerCase() + right.slice(1)}) {
+      throw new Error('Precondition failed: ${precondition}');
+    }`;
+  }
+  const stateMatch = precondition.match(/^(\w+)\s+is\s+(\w+)$/i);
+  if (stateMatch) {
+    const model = stateMatch[1];
+    const state = stateMatch[2];
+    const modelVar = model.charAt(0).toLowerCase() + model.slice(1);
+    return `    // Guard: ${precondition}
+    const ${modelVar}State = await prisma.${modelVar}.findUniqueOrThrow({ where: { id: params.id } });
+    if (${modelVar}State.status !== '${state}') {
+      throw new Error('Precondition failed: ${precondition} (current: ' + ${modelVar}State.status + ')');
+    }`;
+  }
+  return `    // Guard: ${precondition}
+    // TODO: Implement precondition check`;
+}
+function generateStepLogic(steps, context) {
+  const helpers = [];
+  if (steps && steps.length > 0) {
+    const stepCode = steps.map((step, i) => {
+      if (typeof step !== "string") {
+        return `    // Step ${i + 1}: Complex operation \u2014 see expanded definition`;
+      }
+      const ctx = {
+        modelName: context.modelName,
+        prismaModel: context.prismaModel || context.modelName,
+        serviceName: context.serviceName,
+        operationName: context.operationName,
+        stepNum: i + 1
+      };
+      const result = matchStep(step, ctx);
+      if (result.helperMethod) {
+        helpers.push(result.helperMethod);
+      }
+      return result.call;
+    });
+    return {
+      code: `    // === EXECUTE ===
+${stepCode.join("\n\n")}`,
+      helpers
+    };
+  }
+  return {
+    code: `    // === EXECUTE ===
+${inferLogicFromOperationName(context)}`,
+    helpers
+  };
+}
+function inferLogicFromOperationName(context) {
+  const op = context.operationName;
+  const prismaModel = context.prismaModel || context.modelName;
+  const modelVar = prismaModel.charAt(0).toLowerCase() + prismaModel.slice(1);
+  if (op.startsWith("handle")) {
+    const event = op.replace("handle", "");
+    return `    // Event handler: ${op}
+    console.log('[${context.serviceName}] Processing ${event}', params);
+    return { handled: true, event: '${event}' };`;
+  }
+  if (op.startsWith("validate")) {
+    return `    // Validation: ${op}
+    const records = await prisma.${modelVar}.findMany({ where: { id: params.id } });
+    return { valid: records.length > 0, checked: records.length };`;
+  }
+  if (op.startsWith("get") || op.startsWith("list") || op.startsWith("find")) {
+    return `    return await prisma.${modelVar}.findMany({});`;
+  }
+  return `    // TODO: Implement ${op}
+    return { success: true };`;
+}
+function generatePostconditionVerification(postconditions) {
+  if (postconditions.length === 0) return "";
+  const checks = postconditions.map(
+    (pc) => `      console.assert(true, 'POSTCONDITION: ${pc}');`
+  );
+  return `    // === POSTCONDITIONS (dev-mode) ===
+    if (process.env.NODE_ENV === 'development') {
+${checks.join("\n")}
+    }`;
+}
+function generateEventPublishing(sideEffects, operationName) {
+  if (!sideEffects || sideEffects.length === 0) return "";
+  const publishes = sideEffects.map(
+    (event) => `    this.emit('${event}', { operation: '${operationName}', timestamp: new Date().toISOString() });`
+  );
+  return `    // === EVENTS ===
+${publishes.join("\n")}`;
+}
+function generateTransactionWrapper(body, context) {
+  return `    return await prisma.$transaction(async (tx) => {
+${body}
+    });`;
+}
+export {
+  generateBehaviorBody,
+  generateBehaviorWithHelpers,
+  generateEventPublishing,
+  generatePostconditionVerification,
+  generatePreconditionChecks,
+  generateTransactionWrapper
+};