@cosmicdrift/kumiko-framework 0.154.0 → 0.154.2

package/src/engine/feature-ast/extractors/round4.ts

@@ -10,8 +10,6 @@ import type { ScreenDefinition } from "../../types/screen";
 import type {
   AuthClaimsPattern,
   DefineEventPattern,
-  EntityHookPattern,
-  EventMigrationPattern,
   HookPattern,
   HttpRoutePattern,
   JobPattern,
@@ -91,6 +89,25 @@ export function readOptionalRateLimit(value: unknown): RateLimitOption | undefin
   return value as unknown as RateLimitOption;
 }
 
+// r.hook's target: a NameOrRef, a list of them, or an entity-wide
+// `{ allOf: entityRef }` (replaces the old r.entityHook(type, entity, fn)).
+// Checked first so a malformed `{ allOf }` doesn't silently fall through
+// to being read as some other object shape.
+function readHookTarget(
+  node: Node,
+): string | readonly string[] | { readonly allOf: string } | undefined {
+  const obj = node.asKind(SyntaxKind.ObjectLiteralExpression);
+  if (obj) {
+    const allOfProp = obj.getProperty("allOf")?.asKind(SyntaxKind.PropertyAssignment);
+    if (allOfProp) {
+      const initializer = allOfProp.getInitializer();
+      const entityName = initializer && readNameOrRef(initializer);
+      return entityName ? { allOf: entityName } : undefined;
+    }
+  }
+  return readNameOrRefOrList(node);
+}
+
 export function extractHook(
   call: CallExpression,
   sourceFile: SourceFile,
@@ -134,7 +151,7 @@ export function extractHook(
         "object form requires a `target` property",
       );
     }
-    const target = readNameOrRefOrList(targetInit);
+    const target = readHookTarget(targetInit);
     if (!target) {
       return fail(
         "hook",
@@ -196,7 +213,7 @@ export function extractHook(
       "expected a target (NameOrRef or array) as second argument",
     );
   }
-  const target = readNameOrRefOrList(targetArg);
+  const target = readHookTarget(targetArg);
   if (!target) {
     return fail(
       "hook",
@@ -231,154 +248,6 @@ export function extractHook(
   });
 }
 
-export function isEntityHookType(value: string): value is "postSave" | "preDelete" | "postDelete" {
-  return value === "postSave" || value === "preDelete" || value === "postDelete";
-}
-
-export function extractEntityHook(
-  call: CallExpression,
-  sourceFile: SourceFile,
-): ExtractOutput<EntityHookPattern> {
-  const args = call.getArguments();
-  const first = args[0];
-  if (!first) {
-    return fail(
-      "entityHook",
-      sourceLocationFromNode(call, sourceFile),
-      "expected at least one argument",
-    );
-  }
-
-  const obj = first.asKind(SyntaxKind.ObjectLiteralExpression);
-  if (obj && args.length === 1) {
-    const typeInit = obj
-      .getProperty("type")
-      ?.asKind(SyntaxKind.PropertyAssignment)
-      ?.getInitializer()
-      ?.asKind(SyntaxKind.StringLiteral);
-    if (!typeInit) {
-      return fail(
-        "entityHook",
-        sourceLocationFromNode(call, sourceFile),
-        "object form requires a string-literal `type` property",
-      );
-    }
-    const hookType = typeInit.getLiteralValue();
-    if (!isEntityHookType(hookType)) {
-      return fail(
-        "entityHook",
-        sourceLocationFromNode(call, sourceFile),
-        `entity hook type must be postSave, preDelete, or postDelete (got "${hookType}")`,
-      );
-    }
-    const entityInit = obj
-      .getProperty("entity")
-      ?.asKind(SyntaxKind.PropertyAssignment)
-      ?.getInitializer();
-    if (!entityInit) {
-      return fail(
-        "entityHook",
-        sourceLocationFromNode(call, sourceFile),
-        "object form requires an `entity` property",
-      );
-    }
-    const entityName = readNameOrRef(entityInit);
-    if (!entityName) {
-      return fail(
-        "entityHook",
-        sourceLocationFromNode(call, sourceFile),
-        "`entity` must be a string literal or inline { name } object",
-      );
-    }
-    const handlerInit = obj
-      .getProperty("handler")
-      ?.asKind(SyntaxKind.PropertyAssignment)
-      ?.getInitializer();
-    if (!handlerInit) {
-      return fail(
-        "entityHook",
-        sourceLocationFromNode(call, sourceFile),
-        "object form requires a `handler` property",
-      );
-    }
-    const fn = findFunctionLiteral(handlerInit);
-    if (!fn) {
-      return fail(
-        "entityHook",
-        sourceLocationFromNode(call, sourceFile),
-        "handler must be an inline arrow function or function expression",
-      );
-    }
-    const phase = readOptionalPhase(obj);
-    return ok({
-      kind: "entityHook",
-      source: sourceLocationFromNode(call, sourceFile),
-      hookType,
-      entityName,
-      fnBody: sourceLocationFromNode(fn, sourceFile),
-      ...(phase !== undefined && { phase }),
-    });
-  }
-
-  const typeArg = first.asKind(SyntaxKind.StringLiteral);
-  if (!typeArg) {
-    return fail(
-      "entityHook",
-      sourceLocationFromNode(call, sourceFile),
-      "first argument must be a string literal hook type (or use the object form)",
-    );
-  }
-  const hookType = typeArg.getLiteralValue();
-  if (!isEntityHookType(hookType)) {
-    return fail(
-      "entityHook",
-      sourceLocationFromNode(call, sourceFile),
-      `entity hook type must be postSave, preDelete, or postDelete (got "${hookType}")`,
-    );
-  }
-  const entityArg = args[1];
-  if (!entityArg) {
-    return fail(
-      "entityHook",
-      sourceLocationFromNode(call, sourceFile),
-      "expected an entity reference as second argument",
-    );
-  }
-  const entityName = readNameOrRef(entityArg);
-  if (!entityName) {
-    return fail(
-      "entityHook",
-      sourceLocationFromNode(call, sourceFile),
-      "second argument must be a string literal or inline { name } object",
-    );
-  }
-  const fnArg = args[2];
-  if (!fnArg) {
-    return fail(
-      "entityHook",
-      sourceLocationFromNode(call, sourceFile),
-      "expected a hook function as third argument",
-    );
-  }
-  const fn = findFunctionLiteral(fnArg);
-  if (!fn) {
-    return fail(
-      "entityHook",
-      sourceLocationFromNode(call, sourceFile),
-      "third argument must be an inline arrow function or function expression",
-    );
-  }
-  const phase = readOptionalPhase(args[3]);
-  return ok({
-    kind: "entityHook",
-    source: sourceLocationFromNode(call, sourceFile),
-    hookType,
-    entityName,
-    fnBody: sourceLocationFromNode(fn, sourceFile),
-    ...(phase !== undefined && { phase }),
-  });
-}
-
 // guard:dup-ok — intentionale Parallele zu extractTree (round6); verschiedene Feature-AST-Extraktoren by design
 export function extractAuthClaims(
   call: CallExpression,
@@ -805,6 +674,74 @@ export function extractHttpRoute(
   });
 }
 
+// Reads defineEvent's `migrations` option — either the array-of-steps shape
+// used by hand-authored calls (`[{ fromVersion, toVersion, transform }]`,
+// toVersion is redundant on-disk since it is always fromVersion + 1) or the
+// keyed-object canonical shape the Designer renders (`{ "1": transform }`).
+// Keyed by fromVersion (as a string) → the transform closure's location.
+// Skips malformed entries rather than failing the whole defineEvent extract
+// — same "best-effort, degrade gracefully" posture as readDataLiteralNode.
+function extractEventMigrationsFromArray(
+  arr: Node,
+  sourceFile: SourceFile,
+): Record<string, SourceLocation> {
+  const result: Record<string, SourceLocation> = {};
+  const arrLit = arr.asKindOrThrow(SyntaxKind.ArrayLiteralExpression);
+  for (const el of arrLit.getElements()) {
+    const obj = el.asKind(SyntaxKind.ObjectLiteralExpression);
+    if (!obj) continue;
+    const fromInit = obj
+      .getProperty("fromVersion")
+      ?.asKind(SyntaxKind.PropertyAssignment)
+      ?.getInitializer();
+    const fromVersion = fromInit ? readDataLiteralNode(fromInit) : undefined;
+    if (typeof fromVersion !== "number") continue;
+    const transformInit = obj
+      .getProperty("transform")
+      ?.asKind(SyntaxKind.PropertyAssignment)
+      ?.getInitializer();
+    const fn = transformInit ? findFunctionLiteral(transformInit) : undefined;
+    if (!fn) continue;
+    result[String(fromVersion)] = sourceLocationFromNode(fn, sourceFile);
+  }
+  return result;
+}
+
+function extractEventMigrationsFromKeyedObject(
+  objLit: Node,
+  sourceFile: SourceFile,
+): Record<string, SourceLocation> {
+  const result: Record<string, SourceLocation> = {};
+  const obj = objLit.asKindOrThrow(SyntaxKind.ObjectLiteralExpression);
+  for (const prop of obj.getProperties()) {
+    const propAssign = prop.asKind(SyntaxKind.PropertyAssignment);
+    const initializer = propAssign?.getInitializer();
+    const fn = initializer ? findFunctionLiteral(initializer) : undefined;
+    if (!propAssign || !fn) continue;
+    result[readPropertyKey(propAssign)] = sourceLocationFromNode(fn, sourceFile);
+  }
+  return result;
+}
+
+// Reads defineEvent's `migrations` option — either the array-of-steps shape
+// used by hand-authored calls (`[{ fromVersion, toVersion, transform }]`,
+// toVersion is redundant on-disk since it is always fromVersion + 1) or the
+// keyed-object canonical shape the Designer renders (`{ "1": transform }`).
+// Keyed by fromVersion (as a string) → the transform closure's location.
+// Skips malformed entries rather than failing the whole defineEvent extract
+// — same "best-effort, degrade gracefully" posture as readDataLiteralNode.
+function extractEventMigrationsField(
+  node: Node,
+  sourceFile: SourceFile,
+): Readonly<Record<string, SourceLocation>> | undefined {
+  const result = node.asKind(SyntaxKind.ArrayLiteralExpression)
+    ? extractEventMigrationsFromArray(node, sourceFile)
+    : node.asKind(SyntaxKind.ObjectLiteralExpression)
+      ? extractEventMigrationsFromKeyedObject(node, sourceFile)
+      : undefined;
+  return result && Object.keys(result).length > 0 ? result : undefined;
+}
+
 export function extractDefineEvent(
   call: CallExpression,
   sourceFile: SourceFile,
@@ -853,12 +790,20 @@ export function extractDefineEvent(
       const v = readDataLiteralNode(versionInit);
       if (typeof v === "number") version = v;
     }
+    const migrationsInit = obj
+      .getProperty("migrations")
+      ?.asKind(SyntaxKind.PropertyAssignment)
+      ?.getInitializer();
+    const migrations = migrationsInit
+      ? extractEventMigrationsField(migrationsInit, sourceFile)
+      : undefined;
     return ok({
       kind: "defineEvent",
       source: sourceLocationFromNode(call, sourceFile),
       eventName: nameInit.getLiteralValue(),
       schemaSource: sourceLocationFromNode(schemaInit, sourceFile),
       ...(version !== undefined && { version }),
+      ...(migrations !== undefined && { migrations }),
     });
   }
 
@@ -879,152 +824,33 @@ export function extractDefineEvent(
     );
   }
   let version: number | undefined;
+  let migrations: Readonly<Record<string, SourceLocation>> | undefined;
   const optionsArg = args[2];
-  if (optionsArg) {
-    const options = readDataLiteralNode(optionsArg);
-    if (isPlainObject(options) && typeof options["version"] === "number") {
-      version = options["version"];
-    }
-  }
-  return ok({
-    kind: "defineEvent",
-    source: sourceLocationFromNode(call, sourceFile),
-    eventName: nameArg.getLiteralValue(),
-    schemaSource: sourceLocationFromNode(schemaArg, sourceFile),
-    ...(version !== undefined && { version }),
-  });
-}
-
-export function extractEventMigration(
-  call: CallExpression,
-  sourceFile: SourceFile,
-): ExtractOutput<EventMigrationPattern> {
-  const args = call.getArguments();
-  const first = args[0];
-  if (!first) {
-    return fail(
-      "eventMigration",
-      sourceLocationFromNode(call, sourceFile),
-      "expected at least one argument",
-    );
-  }
-
-  const obj = first.asKind(SyntaxKind.ObjectLiteralExpression);
-  if (obj && args.length === 1) {
-    const eventInit = obj
-      .getProperty("event")
-      ?.asKind(SyntaxKind.PropertyAssignment)
-      ?.getInitializer()
-      ?.asKind(SyntaxKind.StringLiteral);
-    if (!eventInit) {
-      return fail(
-        "eventMigration",
-        sourceLocationFromNode(call, sourceFile),
-        "object form requires a string-literal `event` property",
-      );
-    }
-    const fromInit = obj
-      .getProperty("fromVersion")
-      ?.asKind(SyntaxKind.PropertyAssignment)
-      ?.getInitializer();
-    const fromVersion = fromInit ? readDataLiteralNode(fromInit) : undefined;
-    if (typeof fromVersion !== "number") {
-      return fail(
-        "eventMigration",
-        sourceLocationFromNode(call, sourceFile),
-        "fromVersion must be a numeric literal",
-      );
-    }
-    const toInit = obj
-      .getProperty("toVersion")
+  const optionsObj = optionsArg?.asKind(SyntaxKind.ObjectLiteralExpression);
+  if (optionsObj) {
+    const versionInit = optionsObj
+      .getProperty("version")
       ?.asKind(SyntaxKind.PropertyAssignment)
       ?.getInitializer();
-    const toVersion = toInit ? readDataLiteralNode(toInit) : undefined;
-    if (typeof toVersion !== "number") {
-      return fail(
-        "eventMigration",
-        sourceLocationFromNode(call, sourceFile),
-        "toVersion must be a numeric literal",
-      );
+    if (versionInit) {
+      const v = readDataLiteralNode(versionInit);
+      if (typeof v === "number") version = v;
     }
-    const transformInit = obj
-      .getProperty("transform")
+    const migrationsInit = optionsObj
+      .getProperty("migrations")
       ?.asKind(SyntaxKind.PropertyAssignment)
       ?.getInitializer();
-    if (!transformInit) {
-      return fail(
-        "eventMigration",
-        sourceLocationFromNode(call, sourceFile),
-        "object form requires a `transform` property",
-      );
+    if (migrationsInit) {
+      migrations = extractEventMigrationsField(migrationsInit, sourceFile);
     }
-    const fn = findFunctionLiteral(transformInit);
-    if (!fn) {
-      return fail(
-        "eventMigration",
-        sourceLocationFromNode(call, sourceFile),
-        "transform must be an inline arrow function or function expression",
-      );
-    }
-    return ok({
-      kind: "eventMigration",
-      source: sourceLocationFromNode(call, sourceFile),
-      eventName: eventInit.getLiteralValue(),
-      fromVersion,
-      toVersion,
-      transformBody: sourceLocationFromNode(fn, sourceFile),
-    });
-  }
-
-  const nameArg = first.asKind(SyntaxKind.StringLiteral);
-  if (!nameArg) {
-    return fail(
-      "eventMigration",
-      sourceLocationFromNode(call, sourceFile),
-      "first argument must be a string literal event name (or use the object form)",
-    );
-  }
-  const fromArg = args[1];
-  const fromVersion = fromArg ? readDataLiteralNode(fromArg) : undefined;
-  if (typeof fromVersion !== "number") {
-    return fail(
-      "eventMigration",
-      sourceLocationFromNode(call, sourceFile),
-      "fromVersion must be a numeric literal",
-    );
-  }
-  const toArg = args[2];
-  const toVersion = toArg ? readDataLiteralNode(toArg) : undefined;
-  if (typeof toVersion !== "number") {
-    return fail(
-      "eventMigration",
-      sourceLocationFromNode(call, sourceFile),
-      "toVersion must be a numeric literal",
-    );
-  }
-  const transformArg = args[3];
-  if (!transformArg) {
-    return fail(
-      "eventMigration",
-      sourceLocationFromNode(call, sourceFile),
-      "expected a transform function as fourth argument",
-    );
-  }
-  const fn = findFunctionLiteral(transformArg);
-  if (!fn) {
-    return fail(
-      "eventMigration",
-      sourceLocationFromNode(call, sourceFile),
-      "transform must be an inline arrow function or function expression",
-    );
   }
   return ok({
-    kind: "eventMigration",
+    kind: "defineEvent",
     source: sourceLocationFromNode(call, sourceFile),
     eventName: nameArg.getLiteralValue(),
-    fromVersion,
-    toVersion,
-    transformBody: sourceLocationFromNode(fn, sourceFile),
+    schemaSource: sourceLocationFromNode(schemaArg, sourceFile),
+    ...(version !== undefined && { version }),
+    ...(migrations !== undefined && { migrations }),
   });
 }
 

package/src/engine/feature-ast/index.ts

@@ -27,8 +27,6 @@ export type {
   AddConfigArgs,
   AddDefineEventArgs,
   AddEntityArgs,
-  AddEntityHookArgs,
-  AddEventMigrationArgs,
   AddHookArgs,
   AddHttpRouteArgs,
   AddJobArgs,
@@ -59,10 +57,8 @@ export type {
   ConfigPattern,
   DefineEventPattern,
   Editability,
-  EntityHookPattern,
   // Static patterns
   EntityPattern,
-  EventMigrationPattern,
   ExtendsRegistrarPattern,
   FeaturePattern,
   FeaturePatternKind,

package/src/engine/feature-ast/parse.ts

@@ -38,9 +38,7 @@ import {
   extractDefineEvent,
   extractDescribe,
   extractEntity,
-  extractEntityHook,
   extractEnvSchema,
-  extractEventMigration,
   extractExposesApi,
   extractExtendsRegistrar,
   extractHook,
@@ -443,8 +441,6 @@ function dispatchExtractor(
     // Round 4 — mixed (header + body) patterns
     case "hook":
       return extractHook(call, sourceFile);
-    case "entityHook":
-      return extractEntityHook(call, sourceFile);
     case "authClaims":
       return extractAuthClaims(call, sourceFile);
     case "writeHandler":
@@ -457,8 +453,6 @@ function dispatchExtractor(
       return extractHttpRoute(call, sourceFile);
     case "defineEvent":
       return extractDefineEvent(call, sourceFile);
-    case "eventMigration":
-      return extractEventMigration(call, sourceFile);
     case "notification":
       return extractNotification(call, sourceFile);
     case "projection":

package/src/engine/feature-ast/patch.ts

@@ -53,8 +53,11 @@ export type PatternId =
   | { readonly kind: "screen"; readonly id: string }
   | { readonly kind: "writeHandler"; readonly handlerName: string }
   | { readonly kind: "queryHandler"; readonly handlerName: string }
-  | { readonly kind: "hook"; readonly hookType: string; readonly target: string }
-  | { readonly kind: "entityHook"; readonly hookType: string; readonly entityName: string }
+  | {
+      readonly kind: "hook";
+      readonly hookType: string;
+      readonly target: string | { readonly allOf: string };
+    }
   | { readonly kind: "metric"; readonly shortName: string }
   | { readonly kind: "secret"; readonly shortName: string }
   | { readonly kind: "claimKey"; readonly shortName: string }
@@ -66,12 +69,6 @@ export type PatternId =
   | { readonly kind: "projection"; readonly name: string }
   | { readonly kind: "multiStreamProjection"; readonly name: string }
   | { readonly kind: "defineEvent"; readonly eventName: string }
-  | {
-      readonly kind: "eventMigration";
-      readonly eventName: string;
-      readonly fromVersion: number;
-      readonly toVersion: number;
-    }
   | { readonly kind: "extendsRegistrar"; readonly extensionName: string }
   // Singleton patterns — only one per feature, kind alone identifies them.
   | { readonly kind: "requires" }
@@ -362,6 +359,18 @@ function callMatchesId(call: CallExpression, id: PatternId): boolean {
       );
     case "hook":
       // Positional: r.hook(type, target, fn) | Object: { type, target }
+      if (typeof id.target === "object") {
+        // Entity-wide { allOf } target — only ever appears as the object
+        // literal { allOf: entity } (positional or nested in the object
+        // form), never as a bare string, so check both call shapes.
+        if (matchFirstArgString(call, id.hookType)) {
+          return matchAllOfArg(call.getArguments()[1], id.target.allOf);
+        }
+        return (
+          matchObjectProperty(call, "type", id.hookType) &&
+          matchObjectAllOfProperty(call, "target", id.target.allOf)
+        );
+      }
       if (matchFirstArgString(call, id.hookType)) {
         const target = call.getArguments()[1]?.asKind(SyntaxKind.StringLiteral)?.getLiteralValue();
         return target === id.target;
@@ -370,15 +379,6 @@ function callMatchesId(call: CallExpression, id: PatternId): boolean {
         matchObjectProperty(call, "type", id.hookType) &&
         matchObjectProperty(call, "target", id.target)
       );
-    case "entityHook":
-      if (matchFirstArgString(call, id.hookType)) {
-        const ent = call.getArguments()[1]?.asKind(SyntaxKind.StringLiteral)?.getLiteralValue();
-        return ent === id.entityName;
-      }
-      return (
-        matchObjectProperty(call, "type", id.hookType) &&
-        matchObjectProperty(call, "entity", id.entityName)
-      );
     case "metric":
     case "secret":
     case "claimKey":
@@ -419,20 +419,6 @@ function callMatchesId(call: CallExpression, id: PatternId): boolean {
       return (
         matchFirstArgString(call, id.eventName) || matchObjectProperty(call, "name", id.eventName)
       );
-    case "eventMigration": {
-      // Positional: r.eventMigration(name, from, to, fn)
-      if (matchFirstArgString(call, id.eventName)) {
-        const from = numericArg(call, 1);
-        const to = numericArg(call, 2);
-        return from === id.fromVersion && to === id.toVersion;
-      }
-      // Object: { event, fromVersion, toVersion }
-      return (
-        matchObjectProperty(call, "event", id.eventName) &&
-        matchObjectNumericProperty(call, "fromVersion", id.fromVersion) &&
-        matchObjectNumericProperty(call, "toVersion", id.toVersion)
-      );
-    }
     case "extendsRegistrar":
       return matchFirstArgString(call, id.extensionName);
     default: {
@@ -459,25 +445,29 @@ function matchObjectProperty(call: CallExpression, propName: string, expected: s
   return init?.getLiteralValue() === expected;
 }
 
-function matchObjectNumericProperty(
-  call: CallExpression,
-  propName: string,
-  expected: number,
-): boolean {
-  const obj = call.getArguments()[0]?.asKind(SyntaxKind.ObjectLiteralExpression);
-  if (!obj) return false;
+// Matches an r.hook `{ allOf: entity }` target — as the arg node directly
+// (positional call form) or as a nested object property (object call form).
+function matchAllOfArg(node: Node | undefined, expectedEntity: string): boolean {
+  const obj = node?.asKind(SyntaxKind.ObjectLiteralExpression);
   const init = obj
-    .getProperty(propName)
+    ?.getProperty("allOf")
     ?.asKind(SyntaxKind.PropertyAssignment)
     ?.getInitializer()
-    ?.asKind(SyntaxKind.NumericLiteral);
-  return init !== undefined && Number(init.getText()) === expected;
+    ?.asKind(SyntaxKind.StringLiteral);
+  return init?.getLiteralValue() === expectedEntity;
 }
 
-function numericArg(call: CallExpression, idx: number): number | undefined {
-  const lit = call.getArguments()[idx]?.asKind(SyntaxKind.NumericLiteral);
-  if (!lit) return undefined;
-  return Number(lit.getText());
+function matchObjectAllOfProperty(
+  call: CallExpression,
+  propName: string,
+  expectedEntity: string,
+): boolean {
+  const obj = call.getArguments()[0]?.asKind(SyntaxKind.ObjectLiteralExpression);
+  const propInit = obj
+    ?.getProperty(propName)
+    ?.asKind(SyntaxKind.PropertyAssignment)
+    ?.getInitializer();
+  return matchAllOfArg(propInit, expectedEntity);
 }
 
 // =============================================================================