okengine 0.14.1 → 0.15.2

package/src/compiler/extract.ts

@@ -22,6 +22,7 @@ import type {
   Flow,
   Gate,
   Journey,
+  JsonSchema,
   Manifest,
   RateStrategy,
   ResourceRef,
@@ -30,6 +31,7 @@ import type {
   SignalDelivery,
   Slo,
   Store,
+  TablePolicy,
   Trigger,
 } from "../manifest/types.ts";
 import { sqlTableRef } from "../manifest/sql-resource.ts";
@@ -45,6 +47,12 @@ import {
   type InferBinding,
   type Literal,
 } from "./effects-infer.ts";
+import { nameFromFlowFile, pathFromFlowFile } from "./flow-path.ts";
+import {
+  defaultListInSchema,
+  jsonSchemaFromAst,
+  type SchemaExpandContext,
+} from "./schema-from-ast.ts";
 
 /** One source file for extraction. */
 export interface SourceFile {
@@ -67,16 +75,24 @@ export interface ExtractManifestOptions {
 }
 
 /** Internal project scope accumulated across files. */
+type DeclaredSchemaTable = {
+  readonly name: string;
+  readonly columns: Record<string, DeclaredColumn>;
+  readonly rls?: boolean;
+  readonly policies?: Record<string, TablePolicy>;
+};
+
 interface ProjectScope {
   app: string;
   bindings: Map<string, InferBinding>;
   signals: Record<string, Signal>;
   stores: Record<string, Store>;
   /** Binding or table name → declared columns from `store.schema.table`. */
-  schemaTables: Map<
-    string,
-    { readonly name: string; readonly columns: Record<string, DeclaredColumn> }
-  >;
+  schemaTables: Map<string, DeclaredSchemaTable>;
+  /** `const Name = <init>` per file — used to expand flow `in` / `out`. */
+  constInitsByFile: Map<string, Map<string, AstNode>>;
+  /** Unique project-wide const names (ambiguous names omitted). */
+  uniqueConstInits: Map<string, { node: AstNode; file: string }>;
   clocks: Record<string, Clock>;
   gates: Record<string, Gate>;
   /** Local binding name → gate manifest id (policy name or rate expression). */
@@ -119,6 +135,8 @@ export async function extractManifest(options: ExtractManifestOptions = {}): Pro
     signals: {},
     stores: {},
     schemaTables: new Map(),
+    constInitsByFile: new Map(),
+    uniqueConstInits: new Map(),
     clocks: {},
     gates: {},
     gateIds: new Map(),
@@ -144,8 +162,8 @@ export async function extractManifest(options: ExtractManifestOptions = {}): Pro
   });
 
   // Pass 1 — declarations (elements, config, named bindings).
-  for (const { program } of parsed) {
-    collectDeclarations(program, scope);
+  for (const { file, program } of parsed) {
+    collectDeclarations(file.path, program, scope);
   }
 
   // Pass 2 — flows / on() bindings.
@@ -230,13 +248,13 @@ async function readSources(rootDir: string, pattern: string): Promise<SourceFile
   return files;
 }
 
-function collectDeclarations(program: AstNode, scope: ProjectScope): void {
+function collectDeclarations(filePath: string, program: AstNode, scope: ProjectScope): void {
   walk(program, (node) => {
     if (node.type === "CallExpression") {
       visitDeclarationCall(node as CallExpression, program, scope);
     }
     if (node.type === "VariableDeclarator") {
-      visitDeclarator(node as AstNode, scope);
+      visitDeclarator(node as AstNode, filePath, scope);
     }
   });
 
@@ -251,12 +269,13 @@ function collectDeclarations(program: AstNode, scope: ProjectScope): void {
   });
 }
 
-function visitDeclarator(decl: AstNode, scope: ProjectScope): void {
+function visitDeclarator(decl: AstNode, filePath: string, scope: ProjectScope): void {
   const id = (decl as AstNode & { id?: AstNode }).id;
   const init = (decl as AstNode & { init?: AstNode }).init;
   if (!id || !init) return;
   const name = identifierName(id);
   if (!name) return;
+  recordConstInit(scope, filePath, name, unwrapTsExpr(init));
 
   // export const x = on(...) / flow(...) — flow export alias
   if (init.type === "CallExpression") {
@@ -326,7 +345,7 @@ function finalizeRefs(scope: ProjectScope): void {
       if (!declared) continue;
       const existing = table.columns ?? {};
       if (Object.keys(existing).length === 0) {
-        store.tables[name] = { ...table, columns: declared.columns };
+        store.tables[name] = { ...table, ...tableFromDeclared(declared) };
       }
     }
   }
@@ -338,7 +357,7 @@ function finalizeRefs(scope: ProjectScope): void {
     if (!store.tables) continue;
     for (const name of Object.keys(store.tables)) attachedNames.add(name);
   }
-  const orphanByName = new Map<string, { name: string; columns: Record<string, DeclaredColumn> }>();
+  const orphanByName = new Map<string, DeclaredSchemaTable>();
   for (const t of scope.schemaTables.values()) {
     if (!attachedNames.has(t.name)) orphanByName.set(t.name, t);
   }
@@ -351,7 +370,7 @@ function finalizeRefs(scope: ProjectScope): void {
     target.tables = target.tables ?? {};
     for (const t of orphanByName.values()) {
       if (target.tables[t.name]) continue;
-      target.tables[t.name] = { columns: t.columns };
+      target.tables[t.name] = tableFromDeclared(t);
     }
   }
 }
@@ -361,7 +380,8 @@ function collectSchemaTable(call: CallExpression, program: AstNode, scope: Proje
   if (!tableName) return;
   const colsNode = objectArg(call.arguments[1]);
   const columns = colsNode ? parseDeclaredColumns(colsNode) : {};
-  const entry = { name: tableName, columns };
+  const extras = parseSchemaTableExtras(call.arguments[2]);
+  const entry = { name: tableName, columns, ...extras };
   scope.schemaTables.set(tableName, entry);
   const bindingName = enclosingConstName(call, program);
   if (bindingName) {
@@ -396,7 +416,7 @@ function attachSchemaOption(
         const id = (value as Identifier).name;
         const declared = scope.schemaTables.get(id) ?? scope.schemaTables.get(key);
         if (declared) {
-          store.tables[declared.name] = { columns: declared.columns };
+          store.tables[declared.name] = tableFromDeclared(declared);
         } else {
           store.tables[key] = store.tables[key] ?? {};
         }
@@ -406,7 +426,7 @@ function attachSchemaOption(
       if (value.type === "CallExpression") {
         const inline = parseInlineSchemaTable(value as CallExpression);
         if (inline) {
-          store.tables[inline.name] = { columns: inline.columns };
+          store.tables[inline.name] = tableFromDeclared(inline);
           scope.schemaTables.set(inline.name, inline);
         }
       }
@@ -420,9 +440,7 @@ function attachSchemaOption(
   }
 }
 
-function parseInlineSchemaTable(
-  call: CallExpression,
-): { name: string; columns: Record<string, DeclaredColumn> } | undefined {
+function parseInlineSchemaTable(call: CallExpression): DeclaredSchemaTable | undefined {
   const callee = call.callee;
   if (callee.type !== "MemberExpression") return undefined;
   const member = callee as AstNode & { object: AstNode; property: AstNode };
@@ -438,6 +456,121 @@ function parseInlineSchemaTable(
   return {
     name: tableName,
     columns: colsNode ? parseDeclaredColumns(colsNode) : {},
+    ...parseSchemaTableExtras(call.arguments[2]),
+  };
+}
+
+function tableFromDeclared(t: DeclaredSchemaTable): {
+  columns: Record<string, DeclaredColumn>;
+  rls?: boolean;
+  policies?: Record<string, TablePolicy>;
+} {
+  return {
+    columns: t.columns,
+    ...(t.rls ? { rls: true } : {}),
+    ...(t.policies ? { policies: t.policies } : {}),
+  };
+}
+
+function parseSchemaTableExtras(
+  node: AstNode | undefined,
+): Pick<DeclaredSchemaTable, "rls" | "policies"> {
+  if (!node || node.type !== "ArrayExpression") return {};
+  const els = (node as AstNode & { elements?: AstNode[] }).elements ?? [];
+  const policies: Record<string, TablePolicy> = {};
+  let rls = false;
+  for (const el of els) {
+    if (!el || el.type !== "CallExpression") continue;
+    const extra = parseSchemaTableExtra(el as CallExpression);
+    if (!extra) continue;
+    if (extra.kind === "rls") {
+      rls = true;
+      continue;
+    }
+    policies[extra.name] = extra.policy;
+    rls = true;
+  }
+  return {
+    ...(rls ? { rls: true } : {}),
+    ...(Object.keys(policies).length > 0 ? { policies } : {}),
+  };
+}
+
+function parseSchemaTableExtra(
+  call: CallExpression,
+): { kind: "rls" } | { kind: "policy"; name: string; policy: TablePolicy } | undefined {
+  const callee = call.callee;
+  if (callee.type !== "MemberExpression") return undefined;
+  const member = callee as AstNode & { object: AstNode; property: AstNode };
+  const method = identifierName(member.property);
+  if (method === "rls" && isStoreSchemaCallee(member.object)) {
+    return { kind: "rls" };
+  }
+  if (method === "policy" && isStoreSchemaCallee(member.object)) {
+    const name = stringArg(call.arguments[0]);
+    if (!name) return undefined;
+    return { kind: "policy", name, policy: parseTablePolicyOptions(objectArg(call.arguments[1])) };
+  }
+  if (
+    (method === "gate" || method === "owner" || method === "scope") &&
+    isStoreSchemaPolicyCallee(member.object)
+  ) {
+    const key = stringArg(call.arguments[0]);
+    if (!key) return undefined;
+    const opts = objectArg(call.arguments[1]);
+    const command = (stringProp(opts, "for") ??
+      (method === "owner"
+        ? "all"
+        : method === "scope"
+          ? "insert"
+          : "select")) as TablePolicy["for"];
+    const slug = key.replace(/[^A-Za-z0-9]+/g, "_").replace(/^_|_$/g, "");
+    const name = `${method}_${slug}_${command}`;
+    const lit = `'${key.replaceAll("'", "''")}'`;
+    const expr =
+      method === "gate"
+        ? `oke.gate() = ${lit}`
+        : method === "owner"
+          ? `${key} = oke.user()`
+          : `oke.has_scope(${lit})`;
+    const policy: TablePolicy = {
+      for: command,
+      ...(command === "insert"
+        ? { withCheck: expr }
+        : command === "update" || command === "all"
+          ? { using: expr, withCheck: expr }
+          : { using: expr }),
+    };
+    return { kind: "policy", name, policy };
+  }
+  return undefined;
+}
+
+function isStoreSchemaCallee(node: AstNode): boolean {
+  if (node.type !== "MemberExpression") return false;
+  const member = node as AstNode & { object: AstNode; property: AstNode };
+  return identifierName(member.object) === "store" && identifierName(member.property) === "schema";
+}
+
+function isStoreSchemaPolicyCallee(node: AstNode): boolean {
+  if (node.type !== "MemberExpression") return false;
+  const member = node as AstNode & { object: AstNode; property: AstNode };
+  return identifierName(member.property) === "policy" && isStoreSchemaCallee(member.object);
+}
+
+function parseTablePolicyOptions(opts: AstNode | undefined): TablePolicy {
+  const as = stringProp(opts, "as") as TablePolicy["as"];
+  const forCmd = stringProp(opts, "for") as TablePolicy["for"];
+  const using = stringProp(opts, "using");
+  const withCheck = stringProp(opts, "withCheck");
+  const toNode = objectProp(opts, "to");
+  const to = stringArg(toNode) ?? stringArrayProp(opts, "to");
+  return {
+    ...(as ? { as } : {}),
+    ...(to ? { to } : {}),
+    ...(forCmd ? { for: forCmd } : {}),
+    ...(using ? { using } : {}),
+    ...(withCheck ? { withCheck } : {}),
   };
 }
 
@@ -482,6 +615,10 @@ function parseFieldChain(node: AstNode, key: string): DeclaredColumn | undefined
         if (method === "describe") {
           description = stringArg(call.arguments[0]) ?? description;
         }
+        if (method === "defaultFn") {
+          hasDefault = true;
+          defaultValue = defaultValue ?? null;
+        }
         if (method === "default") {
           const lit = call.arguments[0];
           if (lit && lit.type === "Literal") {
@@ -1300,7 +1437,7 @@ function registerFlow(args: {
   scope: ProjectScope;
   exportName: string | undefined;
 }): void {
-  const opts = objectArg(args.flowCall.arguments[1]);
+  const opts = flowOptionsArg(args.flowCall);
   if (!opts) return;
 
   // `flow(\`${unit}.list\`)` inside a helper — name is only known at the
@@ -1309,6 +1446,7 @@ function registerFlow(args: {
 
   const name =
     stringArg(args.flowCall.arguments[0]) ??
+    nameFromFlowFile(args.file.path, args.exportName) ??
     args.exportName ??
     `flow_${Object.keys(args.scope.flows).length + 1}`;
 
@@ -1356,7 +1494,9 @@ function registerFlow(args: {
     }
   }
 
-  const trigger = args.triggerNode ? parseTrigger(args.triggerNode, args.scope) : undefined;
+  const trigger = args.triggerNode
+    ? parseTrigger(args.triggerNode, args.scope, args.file.path)
+    : undefined;
 
   const gates = trigger?.gates;
   const liveFromTrigger = trigger?.live;
@@ -1369,9 +1509,9 @@ function registerFlow(args: {
   }
   if (gates && gates.length > 0) flow.gates = gates;
 
-  const inSchema = schemaProp(opts, "in");
+  const inSchema = schemaProp(opts, "in", args.scope, args.file.path);
   if (inSchema !== undefined) flow.in = inSchema;
-  const outSchema = schemaProp(opts, "out");
+  const outSchema = schemaProp(opts, "out", args.scope, args.file.path);
   if (outSchema !== undefined) flow.out = outSchema;
 
   const errors = parseErrors(objectProp(opts, "errors"));
@@ -1460,8 +1600,8 @@ function registerFlow(args: {
 }
 
 /**
- * `http.resource(path, bag).gate(...).live()` — find the resource call and
- * collect the same chain {@link parseHttpTrigger} reads on a single verb.
+ * `http.resource(path, bag).gate(...).public().live()` — find the resource call
+ * and collect the same chain {@link parseHttpTrigger} reads on a single verb.
  *
  * @param node - First argument to `on(…)`
  * @param scope - Project scope (gate name expansion)
@@ -1492,19 +1632,8 @@ function unwrapResourceMount(
         }
         continue;
       }
+      if (prop === "public") gateNames.push("public");
       if (prop === "live") live = true;
-      continue;
-    }
-    if (item.type === "MemberExpression") {
-      const member = item as AstNode & { object: AstNode; property: AstNode };
-      if (identifierName(member.property) !== "public") continue;
-      const obj = member.object;
-      if (
-        obj.type === "MemberExpression" &&
-        identifierName((obj as AstNode & { property: AstNode }).property) === "gate"
-      ) {
-        gateNames.push("public");
-      }
     }
   }
   if (!httpCall) return undefined;
@@ -1625,32 +1754,86 @@ function registerNamedTableCrud(call: CallExpression, file: SourceFile, scope: P
   const idPath = `${path}/:id`;
   const line = lineAt(file.source, call.start ?? 0);
   const live = boolProp(opts, "liveList") === true;
+  const skipCreate = boolProp(opts, "skipCreate") === true;
+  const ctx = schemaExpandContext(scope, file.path);
+  const createIn = jsonSchemaFromAst(objectProp(opts, "createIn"), ctx);
+  const itemOut = jsonSchemaFromAst(objectProp(opts, "out"), ctx);
+  const updateIn = jsonSchemaFromAst(objectProp(opts, "updateIn"), ctx) ?? createIn;
+  const idSchema: JsonSchema = {
+    type: "object",
+    properties: { id: { type: "string" } },
+    required: ["id"],
+  };
+  const okSchema: JsonSchema = {
+    type: "object",
+    properties: { ok: { const: true, type: "boolean" } },
+    required: ["ok"],
+  };
 
-  const verbs = [
+  const verbs: readonly {
+    readonly op: string;
+    readonly method: string;
+    readonly p: string;
+    readonly eff: Effects | undefined;
+    readonly live?: boolean;
+    readonly in?: JsonSchema;
+    readonly out?: JsonSchema;
+  }[] = [
     {
       op: "list",
       method: "GET",
       p: path,
       eff: storeRef ? { reads: [storeRef] } : undefined,
       live,
+      in: defaultListInSchema(),
+      ...(itemOut ? { out: { type: "array", items: itemOut } } : {}),
+    },
+    ...(skipCreate
+      ? []
+      : [
+          {
+            op: "create",
+            method: "POST",
+            p: path,
+            eff: storeRef ? { writes: [storeRef] } : undefined,
+            ...(createIn ? { in: createIn } : {}),
+            out: idSchema,
+          },
+        ]),
+    {
+      op: "get",
+      method: "GET",
+      p: idPath,
+      eff: storeRef ? { reads: [storeRef] } : undefined,
+      in: idSchema,
+      ...(itemOut ? { out: itemOut } : {}),
+    },
+    {
+      op: "update",
+      method: "PATCH",
+      p: idPath,
+      eff: both,
+      in: updateIn ? mergeIdIntoSchema(updateIn) : idSchema,
+      out: idSchema,
     },
-    { op: "create", method: "POST", p: path, eff: storeRef ? { writes: [storeRef] } : undefined },
-    { op: "get", method: "GET", p: idPath, eff: storeRef ? { reads: [storeRef] } : undefined },
-    { op: "update", method: "PATCH", p: idPath, eff: both },
     {
       op: "delete",
       method: "DELETE",
       p: idPath,
       eff: storeRef ? { reads: [storeRef], writes: [storeRef] } : undefined,
+      in: idSchema,
+      out: okSchema,
     },
-  ] as const;
+  ];
 
   for (const v of verbs) {
     const name = `${unit}.${v.op}`;
     const flow: Flow = {
       trigger: { http: { method: v.method as never, path: v.p } },
       ...(v.eff ? { effects: v.eff as Effects } : {}),
-      ...("live" in v && v.live ? { live: true } : {}),
+      ...(v.live ? { live: true } : {}),
+      ...(v.in !== undefined ? { in: v.in } : {}),
+      ...(v.out !== undefined ? { out: v.out } : {}),
       source: `${file.path}:${line}`,
     };
     scope.flows[name] = flow;
@@ -1664,7 +1847,11 @@ interface ParsedTrigger {
   live?: boolean;
 }
 
-function parseTrigger(node: AstNode, scope: ProjectScope): ParsedTrigger | undefined {
+function parseTrigger(
+  node: AstNode,
+  scope: ProjectScope,
+  filePath?: string,
+): ParsedTrigger | undefined {
   // every("10m")
   if (node.type === "CallExpression") {
     const call = node as CallExpression;
@@ -1677,8 +1864,8 @@ function parseTrigger(node: AstNode, scope: ProjectScope): ParsedTrigger | undef
       return { trigger: {} };
     }
 
-    // http.post("/x").gate(...).live() / http.get("/x").gate.public
-    const http = parseHttpTrigger(call, scope);
+    // http.post("/x").gate(...).live() / http.get("/x").public()
+    const http = parseHttpTrigger(call, scope, filePath);
     if (http) return http;
 
     // table("orders").changed("status") / db.table(orders).changed(...)
@@ -1689,7 +1876,7 @@ function parseTrigger(node: AstNode, scope: ProjectScope): ParsedTrigger | undef
   }
 
   if (node.type === "MemberExpression") {
-    const http = parseHttpTrigger(node, scope);
+    const http = parseHttpTrigger(node, scope, filePath);
     if (http) return http;
   }
 
@@ -1707,8 +1894,12 @@ function parseTrigger(node: AstNode, scope: ProjectScope): ParsedTrigger | undef
   return undefined;
 }
 
-function parseHttpTrigger(leaf: AstNode, scope: ProjectScope): ParsedTrigger | undefined {
-  // Walk: http.METHOD(path).gate(...).live() / .gate.public
+function parseHttpTrigger(
+  leaf: AstNode,
+  scope: ProjectScope,
+  filePath?: string,
+): ParsedTrigger | undefined {
+  // Walk: http.METHOD(path).gate(...).live() / .public()
   const chain = flattenMemberCallChain(leaf);
   let method: string | undefined;
   let path: string | undefined;
@@ -1737,24 +1928,16 @@ function parseHttpTrigger(leaf: AstNode, scope: ProjectScope): ParsedTrigger | u
         continue;
       }
 
+      if (prop === "public") gateNames.push("public");
       if (prop === "live") live = true;
-      continue;
-    }
-
-    if (node.type === "MemberExpression") {
-      const member = node as AstNode & { object: AstNode; property: AstNode };
-      if (identifierName(member.property) !== "public") continue;
-      const obj = member.object;
-      if (
-        obj.type === "MemberExpression" &&
-        identifierName((obj as AstNode & { property: AstNode }).property) === "gate"
-      ) {
-        gateNames.push("public");
-      }
     }
   }
 
-  if (!method || !path) return undefined;
+  if (!method) return undefined;
+  if (!path) {
+    path = filePath ? pathFromFlowFile(filePath) : undefined;
+  }
+  if (!path) return undefined;
 
   const httpMethods = [
     "GET",
@@ -1873,14 +2056,69 @@ function parseSlo(node: AstNode | undefined): Slo | undefined {
   };
 }
 
-function schemaProp(obj: AstNode | undefined, key: string): string | undefined {
+function recordConstInit(scope: ProjectScope, filePath: string, name: string, node: AstNode): void {
+  const byFile = scope.constInitsByFile.get(filePath) ?? new Map<string, AstNode>();
+  byFile.set(name, node);
+  scope.constInitsByFile.set(filePath, byFile);
+  const existing = scope.uniqueConstInits.get(name);
+  if (existing === undefined) {
+    scope.uniqueConstInits.set(name, { node, file: filePath });
+    return;
+  }
+  if (existing.file !== filePath) {
+    scope.uniqueConstInits.delete(name);
+  }
+}
+
+function schemaExpandContext(scope: ProjectScope, filePath: string): SchemaExpandContext {
+  return {
+    filePath,
+    resolveConst: (name, fromFile) => {
+      const local = scope.constInitsByFile.get(fromFile)?.get(name);
+      if (local) return { node: local, file: fromFile };
+      return scope.uniqueConstInits.get(name);
+    },
+    bindings: scope.bindings,
+    tableColumns: (name) => scope.schemaTables.get(name)?.columns,
+  };
+}
+
+function mergeIdIntoSchema(schema: JsonSchema): JsonSchema {
+  if (typeof schema === "string") {
+    return {
+      type: "object",
+      properties: { id: { type: "string" } },
+      required: ["id"],
+    };
+  }
+  const properties = {
+    ...((schema.properties as Record<string, unknown> | undefined) ?? {}),
+    id: { type: "string" },
+  };
+  const required = [
+    ...new Set([...(Array.isArray(schema.required) ? (schema.required as string[]) : []), "id"]),
+  ];
+  return { ...schema, type: "object", properties, required };
+}
+
+function schemaProp(
+  obj: AstNode | undefined,
+  key: string,
+  scope: ProjectScope,
+  filePath: string,
+): JsonSchema | undefined {
   const node = objectProp(obj, key);
   if (!node) return undefined;
-  // Identifier / member schemas → opaque placeholder matching the spec excerpt.
-  if (node.type === "Identifier" || node.type === "MemberExpression") {
+  const expanded = jsonSchemaFromAst(node, schemaExpandContext(scope, filePath));
+  if (expanded) return expanded;
+  // Identifier / member / call that we could not expand — spec excerpt placeholder.
+  if (
+    node.type === "Identifier" ||
+    node.type === "MemberExpression" ||
+    node.type === "CallExpression"
+  ) {
     return "…";
   }
-  if (node.type === "CallExpression") return "…";
   const lit = stringArg(node);
   if (lit) return lit;
   return "…";
@@ -1888,7 +2126,7 @@ function schemaProp(obj: AstNode | undefined, key: string): string | undefined {
 
 // ── AST helpers ────────────────────────────────────────────────────────────
 
-/** Leaf-to-root walk of `http.get("/x").gate.public.live()`. */
+/** Leaf-to-root walk of `http.get("/x").public().live()`. */
 function flattenMemberCallChain(leaf: AstNode): AstNode[] {
   const chain: AstNode[] = [];
   let current: AstNode = leaf;
@@ -2008,6 +2246,19 @@ function objectArg(node: AstNode | undefined): AstNode | undefined {
   return undefined;
 }
 
+/**
+ * `flow("name", { do })` options live in arg1; `flow({ do })` in arg0.
+ *
+ * @param flowCall - `flow(...)` AST node
+ */
+function flowOptionsArg(flowCall: CallExpression): AstNode | undefined {
+  const named = objectArg(flowCall.arguments[1]);
+  if (named) return named;
+  if (stringArg(flowCall.arguments[0]) !== undefined) return undefined;
+  if (isInterpolatedTemplate(flowCall.arguments[0])) return undefined;
+  return objectArg(flowCall.arguments[0]);
+}
+
 function objectProp(obj: AstNode | undefined, key: string): AstNode | undefined {
   if (!obj || obj.type !== "ObjectExpression") return undefined;
   for (const prop of objectProperties(obj)) {