inlay / packages / @inlay / core / test / xrpc.test.ts

import { describe, it } from "node:test";
import assert from "node:assert/strict";
import type { l } from "@atproto/lex";

import {
  $,
  serializeTree,
  deserializeTree,
  resolveBindings,
  type Element,
} from "../src/index.ts";

// Props from deserialized data are untyped — cast when passing back through $.
type Props = l.LexMap & { key?: string };

function xrpc(
  tree: Element,
  component: (input: Record<string, unknown>) => Element
): Element {
  const props = (tree.props ?? {}) as Record<string, unknown>;

  const refs = new Map<string, Element>();
  const refSlots = new Set<object>();
  const requestBody = JSON.stringify(
    serializeTree(props, (el) => {
      if (el.type === "at.inlay.Slot") {
        if (refSlots.has(el as Element)) return el;
        throw new Error("Unexpected Slot in props");
      }
      const id = String(refs.size);
      refs.set(id, el as Element);
      const slot = $("at.inlay.Slot", { id });
      refSlots.add(slot);
      return slot;
    })
  );

  const slots = new Set<object>();
  const input = deserializeTree(JSON.parse(requestBody), (el) => {
    if (el.type === "at.inlay.Slot" && el.props) {
      slots.add(el.props);
      return el;
    }
    throw new Error(`Unexpected element in component input: ${el.type}`);
  }) as Record<string, unknown>;

  const response = component(input);

  const responseBody = JSON.stringify(
    serializeTree(response, (el) => {
      if (el.type === "at.inlay.Slot") {
        if (!el.props || !slots.has(el.props)) {
          throw new Error(`Forged slot in component output`);
        }
      }
      return el;
    })
  );

  return deserializeTree(JSON.parse(responseBody), (el) => {
    if (el.type === "at.inlay.Slot" && el.props) {
      const id = (el.props as Record<string, unknown>).id as string;
      const stashed = refs.get(id);
      if (stashed) return stashed;
      throw new Error(`Unknown slot id: ${id}`);
    }
    return el;
  }) as Element;
}

describe("XRPC flow", () => {
  it("children round-trip through full flow", () => {
    const tree = $(
      "com.example.Card",
      {},
      $("com.example.Text", { value: "hi" })
    );
    assert.deepEqual(
      xrpc(tree, (input) =>
        $("com.example.Box", { children: input.children } as Props)
      ),
      $("com.example.Box", {}, $("com.example.Text", { key: "0", value: "hi" }))
    );
  });

  it("component can reorder children", () => {
    const tree = $(
      "com.example.Layout",
      {},
      $("com.example.Header", { title: "Hi" }),
      $("com.example.Footer", { year: 2025 })
    );
    assert.deepEqual(
      xrpc(tree, (input) => {
        const [a, b] = input.children as unknown[];
        return $("com.example.Box", { children: [b, a] } as Props);
      }),
      $(
        "com.example.Box",
        {},
        $("com.example.Footer", { key: "1", year: 2025 }),
        $("com.example.Header", { key: "0", title: "Hi" })
      )
    );
  });

  it("component can duplicate a child", () => {
    const child = $("com.example.Text", { key: "0", value: "hi" });
    const tree = $(
      "com.example.Card",
      {},
      $("com.example.Text", { value: "hi" })
    );
    assert.deepEqual(
      xrpc(tree, (input) => {
        const c = (input.children as unknown[])[0];
        return $("com.example.Box", { children: [c, c] } as Props);
      }),
      $("com.example.Box", {}, child, child)
    );
  });

  it("component can drop children", () => {
    const tree = $(
      "com.example.Layout",
      {},
      $("com.example.Header"),
      $("com.example.Footer")
    );
    assert.deepEqual(
      xrpc(tree, () => $("com.example.Box", { label: "empty" })),
      $("com.example.Box", { label: "empty" })
    );
  });

  it("elements nested in plain object props round-trip", () => {
    const tree = $("com.example.Card", {
      header: { icon: $("com.example.Icon", { name: "star" }) },
    });
    assert.deepEqual(
      xrpc(tree, (input) => {
        const icon = (input.header as Record<string, unknown>).icon;
        return $("com.example.Box", { content: icon } as Props);
      }),
      $("com.example.Box", {
        content: $("com.example.Icon", { name: "star" }),
      })
    );
  });

  it("primitive-only props pass through unchanged", () => {
    const tree = $("com.example.Spacer", {
      gap: "medium",
      count: 42,
      flag: true,
    });
    assert.deepEqual(
      xrpc(tree, (input) => $("com.example.Box", input as Props)),
      $("com.example.Box", { gap: "medium", count: 42, flag: true })
    );
  });

  it("data with $ keys survives full pipeline", () => {
    const tree = $("com.example.Card", {
      a: { $: "$", type: "app.bsky.feed.post" },
      b: { $: "$weird$value" },
      c: { $: "$$double" },
      d: { $: "hello" },
    });
    assert.deepEqual(
      xrpc(tree, (input) => $("com.example.Box", input as Props)),
      $("com.example.Box", {
        a: { $: "$", type: "app.bsky.feed.post" },
        b: { $: "$weird$value" },
        c: { $: "$$double" },
        d: { $: "hello" },
      })
    );
  });

  it("rejects forged slots even with valid-looking id", () => {
    const tree = $(
      "com.example.Card",
      {},
      $("com.example.Text", { value: "hi" })
    );
    assert.throws(
      () =>
        xrpc(tree, () =>
          $("com.example.Box", {
            stolen: $("at.inlay.Slot", { id: "0" }),
          })
        ),
      /slot/i
    );
  });

  it("named element props round-trip through XRPC", () => {
    const left = $("com.example.Text", { value: "hello" });
    const right = $("com.example.Text", { value: "world" });
    const tree = $("com.example.LeftRight", { left, right });

    assert.deepEqual(
      xrpc(tree, (input) =>
        $(
          "com.example.Row",
          { gap: "medium" },
          $("com.example.Stack", {} as Props, input.left as unknown as Element),
          $("com.example.Stack", {} as Props, input.right as unknown as Element)
        )
      ),
      $(
        "com.example.Row",
        { gap: "medium" },
        $("com.example.Stack", { children: [left] } as Props),
        $("com.example.Stack", { children: [right] } as Props)
      )
    );
  });

  it("same element passed to multiple props gets separate slots", () => {
    const foo = $("com.example.Text", { value: "shared" });
    const tree = $("com.example.LeftRight", { left: foo, right: foo });

    assert.deepEqual(
      xrpc(tree, (input) =>
        $("com.example.Box", {
          first: input.left,
          second: input.right,
        } as Props)
      ),
      $("com.example.Box", { first: foo, second: foo })
    );
  });

  it("component can return same slot multiple times", () => {
    const child = $("com.example.Text", { key: "0", value: "once" });
    const tree = $(
      "com.example.Wrapper",
      {},
      $("com.example.Text", { value: "once" })
    );

    assert.deepEqual(
      xrpc(tree, (input) => {
        const c = (input.children as unknown[])[0];
        return $("com.example.Stack", { children: [c, c] } as Props);
      }),
      $("com.example.Stack", {}, child, child)
    );
  });

  it("nested XRPC calls produce independent refs", () => {
    const tree = $(
      "com.example.Outer",
      {},
      $("com.example.Inner", {}, $("com.example.Text", { value: "leaf" }))
    );

    const afterOuter = xrpc(tree, (input) =>
      $("com.example.Box", { children: input.children } as Props)
    );
    assert.deepEqual(
      afterOuter,
      $(
        "com.example.Box",
        {},
        $(
          "com.example.Inner",
          { key: "0" },
          $("com.example.Text", { key: "0", value: "leaf" })
        )
      )
    );

    const inner = (
      (afterOuter.props as Record<string, unknown>).children as Element[]
    )[0];
    assert.deepEqual(
      xrpc(inner, (input) =>
        $("com.example.Wrapper", { children: input.children } as Props)
      ),
      $(
        "com.example.Wrapper",
        {},
        $("com.example.Text", { key: "0", value: "leaf" })
      )
    );
  });
});

// --- Full pipeline: resolve bindings → XRPC ---

function resolvePath(scope: Record<string, unknown>, path: string[]): unknown {
  let current: unknown = scope;
  for (const seg of path) {
    if (current == null || typeof current !== "object") return undefined;
    current = (current as Record<string, unknown>)[seg];
  }
  return current;
}

describe("resolve → XRPC pipeline", () => {
  it("bindings in props resolve before XRPC", () => {
    const scope = { user: { name: "Dan" } };
    const props = {
      title: $("at.inlay.Binding", { path: ["user", "name"] }),
    };

    // Step 1: resolve bindings in props
    const resolvedProps = resolveBindings(props, (path) => {
      const v = resolvePath(scope, path);
      if (v === undefined) throw new Error(`MISSING:${path.join(".")}`);
      return v;
    }) as Record<string, unknown>;

    // Step 2: XRPC with resolved props
    const tree = $("com.example.Card", resolvedProps as Props);
    const result = xrpc(tree, (input) =>
      $("com.example.Box", { label: input.title } as Props)
    );

    assert.deepEqual(result, $("com.example.Box", { label: "Dan" }));
  });

  it("bindings in children resolve, child elements stash as slots", () => {
    const scope = { greeting: "Hello" };
    const tree = $(
      "com.example.Card",
      {},
      $("com.example.Text", {
        value: $("at.inlay.Binding", { path: ["greeting"] }),
      })
    );

    // resolveBindings is opaque to non-Binding elements —
    // the Binding inside Text's props is NOT resolved here.
    // In the real pipeline, host components resolve their own props.
    // For XRPC, the caller resolves ALL bindings before sending.
    const props = (tree.props ?? {}) as Record<string, unknown>;
    const resolved = resolveBindings(props, (path) => {
      const v = resolvePath(scope, path);
      if (v === undefined) throw new Error(`MISSING:${path.join(".")}`);
      return v;
    }) as Record<string, unknown>;

    // The Text element (with its Binding) passes through opaque
    const children = resolved.children as Element[];
    const textValue = (children[0].props as Record<string, unknown>).value;
    assert.ok(
      typeof textValue === "object" && textValue !== null,
      "Binding inside Text is still an element (opaque)"
    );
  });
});