sailfork / t3code-github / infra/ relay/ src/ agentActivity/ LiveActivities.test.ts

import type {
  RelayAgentActivityAggregateState,
  RelayLiveActivityRegistrationRequest,
} from "@t3tools/contracts/relay";
import { describe, expect, it } from "@effect/vitest";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";

import * as RelayDb from "../db.ts";
import { relayLiveActivities } from "../persistence/schema.ts";
import * as LiveActivities from "./LiveActivities.ts";

const aggregate: RelayAgentActivityAggregateState = {
  title: "T3 Code",
  subtitle: "Agent work in progress",
  activeCount: 1,
  updatedAt: "2026-05-25T00:00:00.000Z",
  activities: [
    {
      environmentId:
        "env" as RelayAgentActivityAggregateState["activities"][number]["environmentId"],
      threadId: "thread" as RelayAgentActivityAggregateState["activities"][number]["threadId"],
      projectTitle: "Project",
      threadTitle: "Thread",
      modelTitle: "gpt-5.4",
      phase: "running",
      status: "Working",
      updatedAt: "2026-05-25T00:00:00.000Z",
      deepLink: "/threads/env/thread",
    },
  ],
};

describe("LiveActivities", () => {
  it.effect("keeps the arming time when the current card re-registers its token", () => {
    const armedAt = "2026-05-25T00:00:00.000Z";
    const insertedValues: Array<Record<string, unknown>> = [];
    const conflictSets: Array<Record<string, unknown> | undefined> = [];
    const fakeDb = {
      select: () => ({
        from: () => ({
          where: () =>
            Effect.succeed([{ activityPushToken: "current-token", remoteStartedAt: armedAt }]),
        }),
      }),
      update: () => ({ set: () => ({ where: () => Effect.void }) }),
      insert: () => ({
        values: (values: Record<string, unknown>) => {
          insertedValues.push(values);
          return {
            onConflictDoUpdate: (config: { readonly set?: Record<string, unknown> }) => {
              conflictSets.push(config.set);
              return Effect.void;
            },
          };
        },
      }),
    } as unknown as RelayDb.RelayDb["Service"];
    const register = (activityPushToken: string) =>
      Effect.flatMap(LiveActivities.LiveActivities, (liveActivities) =>
        liveActivities.register({
          userId: "user-1",
          registration: {
            deviceId: "device-1" as RelayLiveActivityRegistrationRequest["deviceId"],
            activityPushToken:
              activityPushToken as RelayLiveActivityRegistrationRequest["activityPushToken"],
          },
        }),
      );

    return Effect.gen(function* () {
      yield* register("current-token");
      yield* register("new-card-token");

      expect(insertedValues[0]).toMatchObject({ remoteStartedAt: armedAt });
      expect(conflictSets[0]).toMatchObject({ remoteStartedAt: armedAt, lastAggregateJson: null });
      expect(insertedValues[1]?.remoteStartedAt).not.toBe(armedAt);
      expect(conflictSets[1]?.remoteStartedAt).not.toBe(armedAt);
    }).pipe(
      Effect.provide(
        LiveActivities.layer.pipe(Layer.provide(Layer.succeed(RelayDb.RelayDb, fakeDb))),
      ),
    );
  });

  it.effect("preserves ended state when a delayed update delivery is marked", () => {
    const insertedValues: Array<Record<string, unknown>> = [];
    const conflictConfigs: Array<{
      readonly set?: Record<string, unknown>;
    }> = [];

    const fakeDb = {
      insert: (table: unknown) => {
        expect(table).toBe(relayLiveActivities);
        return {
          values: (values: Record<string, unknown>) => {
            insertedValues.push(values);
            return {
              onConflictDoUpdate: (config: { readonly set?: Record<string, unknown> }) => {
                conflictConfigs.push(config);
                return Effect.void;
              },
            };
          },
        };
      },
    } as unknown as RelayDb.RelayDb["Service"];

    return Effect.gen(function* () {
      const liveActivities = yield* LiveActivities.LiveActivities;
      yield* liveActivities.markDelivery({
        userId: "user-2",
        deviceId: "device-1",
        kind: "live_activity_update",
        aggregate,
        deliveredAt: "2026-05-25T00:00:10.000Z",
      });

      expect(insertedValues).toEqual([
        expect.objectContaining({
          userId: "user-2",
          deviceId: "device-1",
          endedAt: null,
        }),
      ]);
      expect(conflictConfigs[0]?.set).toEqual(
        expect.objectContaining({
          endedAt: relayLiveActivities.endedAt,
          lastLiveActivityDeliveryAt: "2026-05-25T00:00:10.000Z",
        }),
      );
    }).pipe(
      Effect.provide(
        LiveActivities.layer.pipe(Layer.provide(Layer.succeed(RelayDb.RelayDb, fakeDb))),
      ),
    );
  });
});