@cosmicdrift/kumiko-framework 1.0.0 → 2.0.0

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

@@ -0,0 +1,243 @@
+import type { CallExpression, Node, SourceFile } from "ts-morph";
+import { SyntaxKind } from "ts-morph";
+import type { LifecycleHookType } from "../../constants";
+import type { AccessRule, RateLimitOption } from "../../types/handlers";
+import type { HookPhase } from "../../types/hooks";
+import type { AuthClaimsPattern, HookPattern } from "../patterns";
+import { sourceLocationFromNode } from "../source-location";
+import {
+  type ExtractOutput,
+  fail,
+  findFunctionLiteral,
+  isPlainObject,
+  ok,
+  readDataLiteralNode,
+  readNameOrRef,
+  readNameOrRefOrList,
+} from "./shared";
+
+export function isHookType(value: string): value is LifecycleHookType | "validation" {
+  return (
+    value === "preSave" ||
+    value === "postSave" ||
+    value === "preDelete" ||
+    value === "postDelete" ||
+    value === "preQuery" ||
+    value === "validation"
+  );
+}
+
+export function readOptionalPhase(node: Node | undefined): HookPhase | undefined {
+  if (!node) return undefined;
+  const obj = readDataLiteralNode(node);
+  if (!isPlainObject(obj)) return undefined;
+  const phase = obj["phase"];
+  if (phase === "inTransaction" || phase === "afterCommit") return phase as HookPhase;
+  return undefined;
+}
+
+export function readOptionalAccessRule(value: unknown): AccessRule | undefined {
+  if (!isPlainObject(value)) return undefined;
+  if (Array.isArray(value["roles"]) && value["roles"].every((r) => typeof r === "string")) {
+    return { roles: value["roles"] as readonly string[] };
+  }
+  if (value["openToAll"] === true) {
+    return { openToAll: true };
+  }
+  return undefined;
+}
+
+export function readOptionalRateLimit(value: unknown): RateLimitOption | undefined {
+  if (!isPlainObject(value)) return undefined;
+  if (typeof value["per"] !== "string") return undefined;
+  if (typeof value["limit"] !== "number") return undefined;
+  if (typeof value["windowSeconds"] !== "number") return undefined;
+  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,
+): ExtractOutput<HookPattern> {
+  const args = call.getArguments();
+  const first = args[0];
+  if (!first) {
+    return fail("hook", 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(
+        "hook",
+        sourceLocationFromNode(call, sourceFile),
+        "object form requires a string-literal `type` property",
+      );
+    }
+    const hookType = typeInit.getLiteralValue();
+    if (!isHookType(hookType)) {
+      return fail(
+        "hook",
+        sourceLocationFromNode(call, sourceFile),
+        `hook type "${hookType}" is not one of the lifecycle types or "validation"`,
+      );
+    }
+    const targetInit = obj
+      .getProperty("target")
+      ?.asKind(SyntaxKind.PropertyAssignment)
+      ?.getInitializer();
+    if (!targetInit) {
+      return fail(
+        "hook",
+        sourceLocationFromNode(call, sourceFile),
+        "object form requires a `target` property",
+      );
+    }
+    const target = readHookTarget(targetInit);
+    if (!target) {
+      return fail(
+        "hook",
+        sourceLocationFromNode(call, sourceFile),
+        "target must be a string literal, an inline { name } object, or an array",
+      );
+    }
+    const handlerInit = obj
+      .getProperty("handler")
+      ?.asKind(SyntaxKind.PropertyAssignment)
+      ?.getInitializer();
+    if (!handlerInit) {
+      return fail(
+        "hook",
+        sourceLocationFromNode(call, sourceFile),
+        "object form requires a `handler` property",
+      );
+    }
+    const fn = findFunctionLiteral(handlerInit);
+    if (!fn) {
+      return fail(
+        "hook",
+        sourceLocationFromNode(call, sourceFile),
+        "handler must be an inline arrow function or function expression",
+      );
+    }
+    const phase = readOptionalPhase(obj);
+    return ok({
+      kind: "hook",
+      source: sourceLocationFromNode(call, sourceFile),
+      hookType,
+      target,
+      fnBody: sourceLocationFromNode(fn, sourceFile),
+      ...(phase !== undefined && { phase }),
+    });
+  }
+
+  const typeArg = first.asKind(SyntaxKind.StringLiteral);
+  if (!typeArg) {
+    return fail(
+      "hook",
+      sourceLocationFromNode(call, sourceFile),
+      "first argument must be a string literal hook type (or use the object form)",
+    );
+  }
+  const hookType = typeArg.getLiteralValue();
+  if (!isHookType(hookType)) {
+    return fail(
+      "hook",
+      sourceLocationFromNode(call, sourceFile),
+      `hook type "${hookType}" is not one of the lifecycle types or "validation"`,
+    );
+  }
+  const targetArg = args[1];
+  if (!targetArg) {
+    return fail(
+      "hook",
+      sourceLocationFromNode(call, sourceFile),
+      "expected a target (NameOrRef or array) as second argument",
+    );
+  }
+  const target = readHookTarget(targetArg);
+  if (!target) {
+    return fail(
+      "hook",
+      sourceLocationFromNode(call, sourceFile),
+      "target must be a string literal, an inline { name } object, or an array",
+    );
+  }
+  const fnArg = args[2];
+  if (!fnArg) {
+    return fail(
+      "hook",
+      sourceLocationFromNode(call, sourceFile),
+      "expected a hook function as third argument",
+    );
+  }
+  const fn = findFunctionLiteral(fnArg);
+  if (!fn) {
+    return fail(
+      "hook",
+      sourceLocationFromNode(call, sourceFile),
+      "third argument must be an inline arrow function or function expression",
+    );
+  }
+  const phase = readOptionalPhase(args[3]);
+  return ok({
+    kind: "hook",
+    source: sourceLocationFromNode(call, sourceFile),
+    hookType,
+    target,
+    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,
+  sourceFile: SourceFile,
+): ExtractOutput<AuthClaimsPattern> {
+  const arg = call.getArguments()[0];
+  if (!arg) {
+    return fail(
+      "authClaims",
+      sourceLocationFromNode(call, sourceFile),
+      "expected a function as first argument",
+    );
+  }
+  const fn = findFunctionLiteral(arg);
+  if (!fn) {
+    return fail(
+      "authClaims",
+      sourceLocationFromNode(call, sourceFile),
+      "first argument must be an inline arrow function or function expression",
+    );
+  }
+  return ok({
+    kind: "authClaims",
+    source: sourceLocationFromNode(call, sourceFile),
+    fnBody: sourceLocationFromNode(fn, sourceFile),
+  });
+}

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

@@ -1,3 +1,35 @@
+export {
+  extractDefineEvent,
+  extractNotification,
+} from "./events";
+export {
+  extractQueryHandler,
+  extractStreamHandler,
+  extractWriteHandler,
+  type ParsedHandlerCall,
+  parseHandlerCall,
+} from "./handlers";
+export {
+  extractAuthClaims,
+  extractHook,
+  isHookType,
+  readOptionalAccessRule,
+  readOptionalPhase,
+  readOptionalRateLimit,
+} from "./hooks";
+export {
+  extractHttpRoute,
+  extractJob,
+  isHttpRouteMethod,
+} from "./jobs-routes";
+export {
+  collectScreenOpaqueProps,
+  extractMultiStreamProjection,
+  extractProjection,
+  extractScreen,
+  readApplyBodies,
+  readScreenStatic,
+} from "./projections-screens";
 export {
   extractDescribe,
   extractOptionalRequires,
@@ -25,43 +57,14 @@ export {
   type NamedOptionsResult,
   readNamedOptions,
 } from "./round3";
-export {
-  collectScreenOpaqueProps,
-  extractAuthClaims,
-  extractDefineEvent,
-  extractEntityHook,
-  extractEventMigration,
-  extractHook,
-  extractHttpRoute,
-  extractJob,
-  extractMultiStreamProjection,
-  extractNotification,
-  extractProjection,
-  extractQueryHandler,
-  extractScreen,
-  extractWriteHandler,
-  isEntityHookType,
-  isHookType,
-  isHttpRouteMethod,
-  type ParsedHandlerCall,
-  parseHandlerCall,
-  readApplyBodies,
-  readOptionalAccessRule,
-  readOptionalPhase,
-  readOptionalRateLimit,
-  readScreenStatic,
-} from "./round4";
 export {
   extractEnvSchema,
   extractExposesApi,
   extractExtendsRegistrar,
-  extractUnmanagedTable,
+  extractStoreTable,
   extractUsesApi,
 } from "./round5";
-export {
-  extractTree,
-  extractTreeActions,
-} from "./round6";
+export { extractTreeActions } from "./round6";
 export type { ExtractOutput } from "./shared";
 export {
   fail,

package/src/engine/feature-ast/extractors/jobs-routes.ts

@@ -0,0 +1,221 @@
+import type { CallExpression, SourceFile } from "ts-morph";
+import { SyntaxKind } from "ts-morph";
+import type { JobDefinition } from "../../types/config";
+import type { HttpRouteMethod } from "../../types/http-route";
+import type { HttpRoutePattern, JobPattern } from "../patterns";
+import { sourceLocationFromNode } from "../source-location";
+import {
+  type ExtractOutput,
+  fail,
+  findFunctionLiteral,
+  isPlainObject,
+  ok,
+  readBooleanProperty,
+  readDataLiteralNode,
+  readPropertyKey,
+} from "./shared";
+
+export function isHttpRouteMethod(value: string): value is HttpRouteMethod {
+  return (
+    value === "GET" ||
+    value === "POST" ||
+    value === "PUT" ||
+    value === "PATCH" ||
+    value === "DELETE" ||
+    value === "HEAD" ||
+    value === "OPTIONS"
+  );
+}
+
+export function extractJob(
+  call: CallExpression,
+  sourceFile: SourceFile,
+): ExtractOutput<JobPattern> {
+  const args = call.getArguments();
+  const first = args[0];
+  if (!first) {
+    return fail("job", sourceLocationFromNode(call, sourceFile), "expected at least one argument");
+  }
+
+  const obj = first.asKind(SyntaxKind.ObjectLiteralExpression);
+  if (obj && args.length === 1) {
+    const nameInit = obj
+      .getProperty("name")
+      ?.asKind(SyntaxKind.PropertyAssignment)
+      ?.getInitializer()
+      ?.asKind(SyntaxKind.StringLiteral);
+    if (!nameInit) {
+      return fail(
+        "job",
+        sourceLocationFromNode(call, sourceFile),
+        "object form requires a string-literal `name` property",
+      );
+    }
+    const handlerInit = obj
+      .getProperty("handler")
+      ?.asKind(SyntaxKind.PropertyAssignment)
+      ?.getInitializer();
+    if (!handlerInit) {
+      return fail(
+        "job",
+        sourceLocationFromNode(call, sourceFile),
+        "object form requires a `handler` property",
+      );
+    }
+    const fn = findFunctionLiteral(handlerInit);
+    if (!fn) {
+      return fail(
+        "job",
+        sourceLocationFromNode(call, sourceFile),
+        "handler must be an inline arrow function or function expression",
+      );
+    }
+    const optionsBag: Record<string, unknown> = {};
+    for (const prop of obj.getProperties()) {
+      const propAssign = prop.asKind(SyntaxKind.PropertyAssignment);
+      if (!propAssign) continue;
+      const key = readPropertyKey(propAssign);
+      if (key === "name" || key === "handler") continue;
+      const init = propAssign.getInitializer();
+      if (!init) continue;
+      const value = readDataLiteralNode(init);
+      if (value === undefined) {
+        return fail(
+          "job",
+          sourceLocationFromNode(call, sourceFile),
+          `option "${key}" could not be read as a plain value`,
+        );
+      }
+      optionsBag[key] = value;
+    }
+    return ok({
+      kind: "job",
+      source: sourceLocationFromNode(call, sourceFile),
+      jobName: nameInit.getLiteralValue(),
+      options: optionsBag as Omit<JobDefinition, "name" | "handler">,
+      handlerBody: sourceLocationFromNode(fn, sourceFile),
+    });
+  }
+
+  const nameArg = first.asKind(SyntaxKind.StringLiteral);
+  if (!nameArg) {
+    return fail(
+      "job",
+      sourceLocationFromNode(call, sourceFile),
+      "first argument must be a string literal job name (or use the object form)",
+    );
+  }
+  const optionsArg = args[1];
+  if (!optionsArg) {
+    return fail(
+      "job",
+      sourceLocationFromNode(call, sourceFile),
+      "expected an options object as second argument",
+    );
+  }
+  const options = readDataLiteralNode(optionsArg);
+  if (!isPlainObject(options)) {
+    return fail(
+      "job",
+      sourceLocationFromNode(call, sourceFile),
+      "options could not be read as a plain object",
+    );
+  }
+  const handlerArg = args[2];
+  if (!handlerArg) {
+    return fail(
+      "job",
+      sourceLocationFromNode(call, sourceFile),
+      "expected a handler function as third argument",
+    );
+  }
+  const fn = findFunctionLiteral(handlerArg);
+  if (!fn) {
+    return fail(
+      "job",
+      sourceLocationFromNode(call, sourceFile),
+      "third argument must be an inline arrow function or function expression",
+    );
+  }
+  return ok({
+    kind: "job",
+    source: sourceLocationFromNode(call, sourceFile),
+    jobName: nameArg.getLiteralValue(),
+    options: options as Omit<JobDefinition, "name" | "handler">,
+    handlerBody: sourceLocationFromNode(fn, sourceFile),
+  });
+}
+
+export function extractHttpRoute(
+  call: CallExpression,
+  sourceFile: SourceFile,
+): ExtractOutput<HttpRoutePattern> {
+  const arg = call.getArguments()[0]?.asKind(SyntaxKind.ObjectLiteralExpression);
+  if (!arg) {
+    return fail(
+      "httpRoute",
+      sourceLocationFromNode(call, sourceFile),
+      "argument must be an inline HttpRouteDefinition object",
+    );
+  }
+  const methodLiteral = arg
+    .getProperty("method")
+    ?.asKind(SyntaxKind.PropertyAssignment)
+    ?.getInitializer()
+    ?.asKind(SyntaxKind.StringLiteral);
+  if (!methodLiteral) {
+    return fail(
+      "httpRoute",
+      sourceLocationFromNode(call, sourceFile),
+      "method must be a string literal",
+    );
+  }
+  const methodValue = methodLiteral.getLiteralValue();
+  if (!isHttpRouteMethod(methodValue)) {
+    return fail(
+      "httpRoute",
+      sourceLocationFromNode(call, sourceFile),
+      `method must be one of GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS (got "${methodValue}")`,
+    );
+  }
+  const pathLiteral = arg
+    .getProperty("path")
+    ?.asKind(SyntaxKind.PropertyAssignment)
+    ?.getInitializer()
+    ?.asKind(SyntaxKind.StringLiteral);
+  if (!pathLiteral) {
+    return fail(
+      "httpRoute",
+      sourceLocationFromNode(call, sourceFile),
+      "path must be a string literal",
+    );
+  }
+  const handlerInit = arg
+    .getProperty("handler")
+    ?.asKind(SyntaxKind.PropertyAssignment)
+    ?.getInitializer();
+  if (!handlerInit) {
+    return fail(
+      "httpRoute",
+      sourceLocationFromNode(call, sourceFile),
+      "missing `handler` property",
+    );
+  }
+  const fn = findFunctionLiteral(handlerInit);
+  if (!fn) {
+    return fail(
+      "httpRoute",
+      sourceLocationFromNode(call, sourceFile),
+      "handler must be an inline arrow function or function expression",
+    );
+  }
+  const anonymous = readBooleanProperty(arg, "anonymous");
+  return ok({
+    kind: "httpRoute",
+    source: sourceLocationFromNode(call, sourceFile),
+    method: methodValue,
+    path: pathLiteral.getLiteralValue(),
+    handlerBody: sourceLocationFromNode(fn, sourceFile),
+    ...(anonymous === true && { anonymous: true }),
+  });
+}