import { describe, expect, it, vi } from "@effect/vitest";
import {
EnvironmentId,
ThreadId,
AuthFilesystemReadScope,
EnvironmentAuthorizationError,
type FilesystemEntryMetadata,
type FilesystemGetMetadataInput,
WS_METHODS,
} from "@t3tools/contracts";
import * as Clock from "effect/Clock";
import * as Effect from "effect/Effect";
import * as Deferred from "effect/Deferred";
import * as Fiber from "effect/Fiber";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as Stream from "effect/Stream";
import * as Schema from "effect/Schema";
import * as SubscriptionRef from "effect/SubscriptionRef";
import * as TestClock from "effect/testing/TestClock";
import { Atom, AtomRegistry } from "effect/reactivity";
import { AVAILABLE_CONNECTION_STATE, BearerConnectionTarget } from "../connection/model.ts";
import * as EnvironmentRegistry from "../connection/registry.ts";
import * as EnvironmentSupervisor from "../connection/supervisor.ts";
import type { RpcSession } from "../rpc/session.ts";
import { createFileMetadataAtoms } from "./fileMetadata.ts";
const ENVIRONMENT_ID = EnvironmentId.make("metadata-environment");
const OTHER_ENVIRONMENT_ID = EnvironmentId.make("metadata-other-environment");
const makeHarness = Effect.fnUntraced(function* () {
const batches: string[][] = [];
const values = new Map<string, FilesystemEntryMetadata | null>();
const failure = { denied: false };
const response = { wait: Effect.void as Effect.Effect<void> };
const makeSession = () =>
({
client: {
[WS_METHODS.filesystemGetMetadata]: (input: FilesystemGetMetadataInput) =>
Effect.gen(function* () {
batches.push([...input.paths]);
if (failure.denied)
return yield* new EnvironmentAuthorizationError({
requiredScope: AuthFilesystemReadScope,
message: "File access is not granted.",
});
const entries = input.paths.map((path) => values.get(path) ?? null);
yield* response.wait;
return { entries };
}),
},
}) as unknown as RpcSession;
const session = yield* SubscriptionRef.make(Option.some(makeSession()));
const state = yield* SubscriptionRef.make({
...AVAILABLE_CONNECTION_STATE,
phase: "connected" as const,
});
const supervisor = {
target: new BearerConnectionTarget({
environmentId: ENVIRONMENT_ID,
label: "Test",
connectionId: "test",
}),
session,
state,
} as EnvironmentSupervisor.EnvironmentSupervisor["Service"];
const otherSupervisor = {
...supervisor,
target: new BearerConnectionTarget({
environmentId: OTHER_ENVIRONMENT_ID,
label: "Test",
connectionId: "test",
}),
session: yield* SubscriptionRef.make(Option.some(makeSession())),
} as EnvironmentSupervisor.EnvironmentSupervisor["Service"];
const getSupervisor = (environmentId: EnvironmentId) =>
environmentId === OTHER_ENVIRONMENT_ID ? otherSupervisor : supervisor;
const environmentRegistry = {
run: (environmentId, effect) =>
Effect.provideService(
effect,
EnvironmentSupervisor.EnvironmentSupervisor,
getSupervisor(environmentId),
),
followStream: (environmentId, stream) =>
Stream.provideService(
stream,
EnvironmentSupervisor.EnvironmentSupervisor,
getSupervisor(environmentId),
),
} as EnvironmentRegistry.EnvironmentRegistry["Service"];
const clock = yield* Clock.Clock;
const runtime = Atom.runtime(
Layer.merge(
Layer.succeed(EnvironmentRegistry.EnvironmentRegistry, environmentRegistry),
Layer.succeed(Clock.Clock, clock),
),
);
const atoms = createFileMetadataAtoms(runtime);
const registry = AtomRegistry.make();
yield* Effect.addFinalizer(() => Effect.sync(() => registry.dispose()));
const atom = (path: string, environmentId = ENVIRONMENT_ID, threadId?: ThreadId) =>
atoms.metadata({ environmentId, input: { path, ...(threadId ? { threadId } : {}) } });
const read = (path: string, environmentId = ENVIRONMENT_ID, threadId?: ThreadId) =>
AtomRegistry.getResult(registry, atom(path, environmentId, threadId), {
suspendOnWaiting: true,
}).pipe(Effect.tap(() => Effect.yieldNow));
const seed = (path: string, kind: "file" | "directory") =>
atoms
.rememberEntries("/workspace", [{ path, kind }])
.pipe(Effect.provideService(EnvironmentSupervisor.EnvironmentSupervisor, supervisor));
return {
batches,
values,
registry,
atom,
read,
seed,
session,
makeSession,
atoms,
supervisor,
failure,
response,
};
});
describe("file metadata", () => {
it.effect("refreshes expired mounted misses while retaining known thread entries", () =>
Effect.gen(function* () {
vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] });
yield* Effect.addFinalizer(() => Effect.sync(() => vi.useRealTimers()));
const h = yield* makeHarness();
const threadId = ThreadId.make("new-directory-thread");
h.registry.mount(h.atoms.retainThread({ environmentId: ENVIRONMENT_ID, threadId }));
const path = "/home/user/games/hl1";
h.registry.mount(h.atom(path, ENVIRONMENT_ID, threadId));
h.values.set("/workspace/known", { kind: "file", byteLength: 5 });
expect(yield* h.read(path, ENVIRONMENT_ID, threadId)).toBeNull();
yield* h.read("/workspace/known", ENVIRONMENT_ID, threadId);
h.values.set(path, { kind: "directory" });
h.registry.refresh(h.atom(path, ENVIRONMENT_ID, threadId));
expect(yield* h.read(path, ENVIRONMENT_ID, threadId)).toBeNull();
h.failure.denied = true;
yield* TestClock.adjust(60_001);
yield* Effect.promise(() => vi.advanceTimersByTimeAsync(60_000));
expect(yield* h.read(path, ENVIRONMENT_ID, threadId).pipe(Effect.flip)).toBeInstanceOf(
EnvironmentAuthorizationError,
);
h.failure.denied = false;
yield* TestClock.adjust(60_001);
yield* Effect.promise(() => vi.advanceTimersByTimeAsync(60_000));
expect(yield* h.read(path, ENVIRONMENT_ID, threadId)).toEqual({ kind: "directory" });
h.registry.refresh(h.atom("/workspace/known", ENVIRONMENT_ID, threadId));
expect(yield* h.read("/workspace/known", ENVIRONMENT_ID, threadId)).toEqual({
kind: "file",
byteLength: 5,
});
yield* TestClock.adjust(60_001);
yield* Effect.promise(() => vi.advanceTimersByTimeAsync(60_000));
expect(h.batches).toEqual([[path], ["/workspace/known"], [path], [path]]);
}).pipe(Effect.scoped),
);
it.effect("does not seed a different path from a literal name with a numeric suffix", () =>
Effect.gen(function* () {
const h = yield* makeHarness();
yield* h.seed("report:123", "directory");
h.values.set("/workspace/report", { kind: "file", byteLength: 5 });
expect(yield* h.read("/workspace/report")).toEqual({ kind: "file", byteLength: 5 });
expect(yield* h.read("/workspace/report:123")).toEqual({ kind: "directory" });
yield* h.atoms
.rememberFile("/workspace", {
relativePath: "/workspace/read:12:3",
byteLength: 100,
})
.pipe(Effect.provideService(EnvironmentSupervisor.EnvironmentSupervisor, h.supervisor));
expect(yield* h.read("/workspace/read:12:3")).toEqual({ kind: "file", byteLength: 100 });
expect(yield* h.read("/workspace/read")).toBeNull();
expect(h.batches).toEqual([["/workspace/report"], ["/workspace/read"]]);
}).pipe(Effect.scoped),
);
it.effect("retries only paths invalidated while their response is in flight", () =>
Effect.gen(function* () {
const h = yield* makeHarness();
const threadId = ThreadId.make("in-flight-thread");
h.registry.mount(h.atoms.retainThread({ environmentId: ENVIRONMENT_ID, threadId }));
const started = yield* Deferred.make<void>();
const release = yield* Deferred.make<void>();
h.response.wait = Deferred.succeed(started, undefined).pipe(
Effect.andThen(Deferred.await(release)),
);
h.values.set("/workspace/file", { kind: "file", byteLength: 5 });
h.values.set("/workspace/unchanged", { kind: "directory" });
const read = yield* Effect.all(
[h.read("/workspace/file", ENVIRONMENT_ID, threadId), h.read("/workspace/unchanged")],
{ concurrency: "unbounded" },
).pipe(Effect.forkChild);
yield* Deferred.await(started);
yield* h.atoms
.invalidate("/workspace/file")
.pipe(Effect.provideService(EnvironmentSupervisor.EnvironmentSupervisor, h.supervisor));
h.values.set("/workspace/file", { kind: "file", byteLength: 10 });
h.response.wait = Effect.void;
yield* Deferred.succeed(release, undefined);
expect(yield* Fiber.join(read)).toEqual([
{ kind: "file", byteLength: 10 },
{ kind: "directory" },
]);
expect(h.batches).toEqual([["/workspace/file", "/workspace/unchanged"], ["/workspace/file"]]);
h.registry.refresh(h.atom("/workspace/file", ENVIRONMENT_ID, threadId));
expect(yield* h.read("/workspace/file", ENVIRONMENT_ID, threadId)).toEqual({
kind: "file",
byteLength: 10,
});
expect(h.batches).toHaveLength(2);
}).pipe(Effect.scoped),
);
it.effect("an offscreen invalidation waits until that path is read again", () =>
Effect.gen(function* () {
const h = yield* makeHarness();
const threadId = ThreadId.make("offscreen-thread");
h.registry.mount(h.atoms.retainThread({ environmentId: ENVIRONMENT_ID, threadId }));
yield* h.read("/workspace/file", ENVIRONMENT_ID, threadId);
yield* h.atoms
.invalidate("/workspace/file")
.pipe(Effect.provideService(EnvironmentSupervisor.EnvironmentSupervisor, h.supervisor));
h.atoms.refreshPath(ENVIRONMENT_ID, "/workspace/file", h.registry);
yield* Effect.yieldNow;
expect(h.batches).toHaveLength(1);
h.values.set("/workspace/file", { kind: "directory" });
expect(yield* h.read("/workspace/file", ENVIRONMENT_ID, threadId)).toEqual({
kind: "directory",
});
expect(h.batches).toHaveLength(2);
}).pipe(Effect.scoped),
);
it.effect("invalidates a changed retained path without refetching other paths", () =>
Effect.gen(function* () {
const h = yield* makeHarness();
const threadId = ThreadId.make("changing-thread");
h.registry.mount(h.atoms.retainThread({ environmentId: ENVIRONMENT_ID, threadId }));
h.values.set("/workspace/file", { kind: "file", byteLength: 5 });
const file = h.atom("/workspace/file", ENVIRONMENT_ID, threadId);
h.registry.mount(file);
yield* h.read("/workspace/file", ENVIRONMENT_ID, threadId);
yield* h.read("/workspace/unchanged", ENVIRONMENT_ID, threadId);
const before = h.batches.length;
h.values.set("/workspace/file", { kind: "file", byteLength: 10 });
yield* h.atoms
.invalidate("/workspace/file")
.pipe(Effect.provideService(EnvironmentSupervisor.EnvironmentSupervisor, h.supervisor));
h.atoms.refreshPath(ENVIRONMENT_ID, "/workspace/file", h.registry);
expect(yield* h.read("/workspace/file", ENVIRONMENT_ID, threadId)).toEqual({
kind: "file",
byteLength: 10,
});
h.registry.refresh(h.atom("/workspace/unchanged", ENVIRONMENT_ID, threadId));
yield* h.read("/workspace/unchanged", ENVIRONMENT_ID, threadId);
expect(h.batches.slice(before)).toEqual([["/workspace/file"]]);
}).pipe(Effect.scoped),
);
it.effect("a reconnect discards retained metadata from the previous session", () =>
Effect.gen(function* () {
const h = yield* makeHarness();
const threadId = ThreadId.make("reconnected-thread");
h.registry.mount(h.atoms.retainThread({ environmentId: ENVIRONMENT_ID, threadId }));
h.values.set("/workspace/file", { kind: "file" });
yield* h.read("/workspace/file", ENVIRONMENT_ID, threadId);
h.values.set("/workspace/file", { kind: "directory" });
yield* SubscriptionRef.set(h.session, Option.some(h.makeSession()));
h.registry.refresh(h.atom("/workspace/file", ENVIRONMENT_ID, threadId));
expect(yield* h.read("/workspace/file", ENVIRONMENT_ID, threadId)).toEqual({
kind: "directory",
});
expect(h.batches).toHaveLength(2);
}).pipe(Effect.scoped),
);
it.effect("keeps batches and cached paths separate across environments", () =>
Effect.gen(function* () {
const h = yield* makeHarness();
yield* h.seed("known", "directory");
expect(yield* h.read("/workspace/known", OTHER_ENVIRONMENT_ID)).toBeNull();
expect(h.batches).toEqual([["/workspace/known"]]);
yield* Effect.all(
[h.read("/workspace/new"), h.read("/workspace/new", OTHER_ENVIRONMENT_ID)],
{ concurrency: "unbounded" },
);
expect(h.batches.slice(1)).toEqual([["/workspace/new"], ["/workspace/new"]]);
}).pipe(Effect.scoped),
);
it.effect("settles a failed batch and can retry after access is granted", () =>
Effect.gen(function* () {
const h = yield* makeHarness();
h.failure.denied = true;
const failures = yield* Effect.all(
[h.read("/workspace/a").pipe(Effect.flip), h.read("/workspace/b").pipe(Effect.flip)],
{ concurrency: "unbounded" },
);
expect(failures.every(Schema.is(EnvironmentAuthorizationError))).toBe(true);
h.failure.denied = false;
h.values.set("/workspace/a", { kind: "directory" });
h.registry.refresh(h.atom("/workspace/a"));
expect(yield* h.read("/workspace/a")).toEqual({ kind: "directory" });
}).pipe(Effect.scoped),
);
it.effect("reuses file read sizes and normalizes Windows cache keys", () =>
Effect.gen(function* () {
const h = yield* makeHarness();
yield* h.atoms
.rememberFile("C:\\Workspace", {
relativePath: "file",
byteLength: 100,
})
.pipe(Effect.provideService(EnvironmentSupervisor.EnvironmentSupervisor, h.supervisor));
expect(yield* h.read("c:/workspace/file/")).toEqual({ kind: "file", byteLength: 100 });
expect(h.batches).toHaveLength(0);
}).pipe(Effect.scoped),
);
it.effect("batches mounted paths and deduplicates repeated chips", () =>
Effect.gen(function* () {
const h = yield* makeHarness();
h.values.set("/workspace/file", { kind: "file", byteLength: 5 });
h.values.set("/workspace/folder.ts", { kind: "directory" });
const results = yield* Effect.all(
[h.read("/workspace/file"), h.read("/workspace/folder.ts"), h.read("/workspace/file")],
{ concurrency: "unbounded" },
);
expect(h.batches).toEqual([["/workspace/file", "/workspace/folder.ts"]]);
expect(results).toEqual([
{ kind: "file", byteLength: 5 },
{ kind: "directory" },
{ kind: "file", byteLength: 5 },
]);
yield* h.read("/workspace/file");
expect(h.batches).toHaveLength(1);
}).pipe(Effect.scoped),
);
it.effect("uses search and tree kinds without another request", () =>
Effect.gen(function* () {
const h = yield* makeHarness();
yield* h.seed("folder.ts", "directory");
expect(yield* h.read("/workspace/folder.ts")).toEqual({ kind: "directory" });
expect(h.batches).toHaveLength(0);
}).pipe(Effect.scoped),
);
it.effect("splits large mounts into bounded batches and caches misses", () =>
Effect.gen(function* () {
const h = yield* makeHarness();
yield* Effect.all(
Array.from({ length: 130 }, (_, i) => h.read(`/workspace/${i}`)),
{ concurrency: "unbounded" },
);
expect(h.batches.flat()).toHaveLength(130);
expect(h.batches.map((batch) => batch.length)).toEqual([64, 64, 2]);
expect(h.batches.every((batch) => batch.length <= 64)).toBe(true);
const count = h.batches.length;
yield* h.read("/workspace/0");
expect(h.batches).toHaveLength(count);
}).pipe(Effect.scoped),
);
});