refactor: first effect vertical slice

Author: jonathanlab

apps/code/src/main/di/container.ts

@@ -167,7 +167,6 @@ import type { ExternalAppsPreferences } from "@posthog/workspace-server/services
 import { foldersModule } from "@posthog/workspace-server/services/folders/folders.module";
 import { GitService } from "@posthog/workspace-server/services/git/service";
 import { TaskPrStatusService } from "@posthog/workspace-server/services/git/task-pr-status";
-import { githubReleasesModule } from "@posthog/workspace-server/services/github-releases/github-releases.module";
 import {
   HANDOFF_GIT_GATEWAY,
   HANDOFF_LOG_GATEWAY,
@@ -607,7 +606,6 @@ container.load(posthogPluginModule);
 container.bind(MAIN_POSTHOG_PLUGIN_SERVICE).toService(POSTHOG_PLUGIN_SERVICE);
 container.load(skillsModule);
 container.load(skillsMarketplaceModule);
-container.load(githubReleasesModule);
 container.load(onboardingImportModule);
 container.load(claudeCliSessionsModule);
 container.load(additionalDirectoriesModule);

packages/host-router/package.json

@@ -25,6 +25,7 @@
     "@posthog/workspace-client": "workspace:*",
     "@posthog/workspace-server": "workspace:*",
     "@trpc/client": "catalog:",
+    "effect": "catalog:",
     "zod": "^4.4.3"
   },
   "peerDependencies": {

packages/host-router/src/effect-runtime.ts

@@ -0,0 +1,22 @@
+import { GitHubReleases } from "@posthog/workspace-server/services/github-releases/github-releases";
+import { type Effect, Layer, ManagedRuntime } from "effect";
+
+/**
+ * Every converted Effect service's live layer goes here. This is the single
+ * place the host's Effect services are composed; it grows as more services
+ * migrate off Inversify.
+ */
+const AppLayer = Layer.mergeAll(GitHubReleases.Live);
+
+/** One shared runtime for the whole host process — services are singletons. */
+const appRuntime = ManagedRuntime.make(AppLayer);
+
+/**
+ * Runs an Effect through the shared host runtime and hands tRPC back a Promise.
+ * The tRPC request's abort signal is forwarded, so a cancelled request
+ * interrupts the fiber and releases its resources.
+ */
+export const runEffect = <A, E>(
+  effect: Effect.Effect<A, E, Layer.Success<typeof AppLayer>>,
+  signal?: AbortSignal,
+): Promise<A> => appRuntime.runPromise(effect, { signal });

packages/host-router/src/routers/github-releases.router.ts

@@ -1,14 +1,14 @@
 import { publicProcedure, router } from "@posthog/host-trpc/trpc";
-import type { GitHubReleasesService } from "@posthog/workspace-server/services/github-releases/github-releases";
-import { GITHUB_RELEASES_SERVICE } from "@posthog/workspace-server/services/github-releases/identifiers";
+import { GitHubReleases } from "@posthog/workspace-server/services/github-releases/github-releases";
 import { listReleasesOutput } from "@posthog/workspace-server/services/github-releases/schemas";
+import { Effect } from "effect";
+import { runEffect } from "../effect-runtime";
 
 export const githubReleasesRouter = router({
-  list: publicProcedure
-    .output(listReleasesOutput)
-    .query(({ ctx }) =>
-      ctx.container
-        .get<GitHubReleasesService>(GITHUB_RELEASES_SERVICE)
-        .listReleases(),
+  list: publicProcedure.output(listReleasesOutput).query((opts) =>
+    runEffect(
+      Effect.flatMap(GitHubReleases, (service) => service.list()),
+      opts.signal,
     ),
+  ),
 });

packages/workspace-server/package.json

@@ -33,6 +33,7 @@
     "@trpc/server": "catalog:",
     "better-sqlite3": "^12.8.0",
     "drizzle-orm": "^0.45.1",
+    "effect": "catalog:",
     "fflate": "^0.8.2",
     "hono": "catalog:",
     "ignore": "^7.0.5",
@@ -44,6 +45,7 @@
     "zod": "^4.1.12"
   },
   "devDependencies": {
+    "@effect/vitest": "catalog:",
     "@inversifyjs/strongly-typed": "2.2.0",
     "@posthog/tsconfig": "workspace:*",
     "@types/better-sqlite3": "^7.6.13",

packages/workspace-server/src/services/github-releases/github-releases.module.ts

@@ -1,5 +1,14 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { GitHubReleasesService } from "./github-releases";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  vi,
+} from "@effect/vitest";
+import { Duration, Effect } from "effect";
+import { TestClock } from "effect/testing";
+import { GitHubReleases } from "./github-releases";
 
 const sampleReleases = [
   {
@@ -31,68 +40,74 @@ const sampleReleases = [
   },
 ];
 
-describe("GitHubReleasesService", () => {
-  let fetchMock: ReturnType<typeof vi.fn>;
+const okResponse = (body: unknown) =>
+  ({ ok: true, status: 200, json: async () => body }) as unknown as Response;
 
-  beforeEach(() => {
-    fetchMock = vi.fn(async () => ({
-      ok: true,
-      status: 200,
-      json: async () => sampleReleases,
-    }));
-    vi.stubGlobal("fetch", fetchMock);
-  });
+let fetchMock: ReturnType<typeof vi.fn>;
 
-  afterEach(() => {
-    vi.unstubAllGlobals();
-  });
+beforeEach(() => {
+  fetchMock = vi.fn(async () => okResponse(sampleReleases));
+  vi.stubGlobal("fetch", fetchMock);
+});
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
 
-  it("maps releases, strips the v prefix and drops drafts", async () => {
-    const service = new GitHubReleasesService();
-    const { releases } = await service.listReleases();
+describe("GitHubReleases", () => {
+  it.effect("maps releases, strips the v prefix and drops drafts", () =>
+    Effect.gen(function* () {
+      const { list } = yield* GitHubReleases;
+      const { releases } = yield* list();
 
-    expect(releases).toHaveLength(2);
-    expect(releases[0]).toEqual({
-      version: "1.2.0",
-      name: "v1.2.0",
-      notes: "## Notes\n- thing",
-      date: "2026-06-20T00:00:00Z",
-      isPrerelease: false,
-      htmlUrl: "https://github.com/PostHog/code/releases/tag/v1.2.0",
-    });
-    // empty name falls back to the tag; null body becomes an empty string
-    expect(releases[1]).toMatchObject({
-      version: "1.1.0",
-      name: "v1.1.0",
-      notes: "",
-      isPrerelease: true,
-    });
-  });
+      expect(releases).toHaveLength(2);
+      expect(releases[0]).toEqual({
+        version: "1.2.0",
+        name: "v1.2.0",
+        notes: "## Notes\n- thing",
+        date: "2026-06-20T00:00:00Z",
+        isPrerelease: false,
+        htmlUrl: "https://github.com/PostHog/code/releases/tag/v1.2.0",
+      });
+      // empty name falls back to the tag; null body becomes an empty string
+      expect(releases[1]).toMatchObject({
+        version: "1.1.0",
+        name: "v1.1.0",
+        notes: "",
+        isPrerelease: true,
+      });
+    }).pipe(Effect.provide(GitHubReleases.Live)),
+  );
 
-  it("caches results within the TTL", async () => {
-    const service = new GitHubReleasesService();
-    await service.listReleases();
-    await service.listReleases();
-    expect(fetchMock).toHaveBeenCalledTimes(1);
-  });
+  it.effect("caches results within the TTL", () =>
+    Effect.gen(function* () {
+      const { list } = yield* GitHubReleases;
+      yield* list();
+      yield* list();
+      expect(fetchMock).toHaveBeenCalledTimes(1);
+    }).pipe(Effect.provide(GitHubReleases.Live)),
+  );
 
-  it("throws on non-ok responses", async () => {
-    fetchMock.mockResolvedValueOnce({ ok: false, status: 503 });
-    const service = new GitHubReleasesService();
-    await expect(service.listReleases()).rejects.toThrow();
-  });
+  it.effect("fails on a non-ok response when there is no cache", () =>
+    Effect.gen(function* () {
+      fetchMock.mockResolvedValueOnce({ ok: false, status: 503 });
+      const { list } = yield* GitHubReleases;
+      const error = yield* Effect.flip(list());
+      expect(error._tag).toBe("GitHubReleasesError");
+    }).pipe(Effect.provide(GitHubReleases.Live)),
+  );
 
-  it("serves stale cache when a later refetch fails", async () => {
-    const nowSpy = vi.spyOn(Date, "now").mockReturnValue(0);
-    const service = new GitHubReleasesService();
-    const first = await service.listReleases();
+  it.effect("serves stale cache when a later refetch fails", () =>
+    Effect.gen(function* () {
+      const { list } = yield* GitHubReleases;
+      const first = yield* list();
 
-    nowSpy.mockReturnValue(11 * 60_000);
-    fetchMock.mockResolvedValueOnce({ ok: false, status: 500 });
-    const second = await service.listReleases();
+      yield* TestClock.adjust(Duration.millis(11 * 60_000));
+      fetchMock.mockResolvedValueOnce({ ok: false, status: 500 });
+      const second = yield* list();
 
-    expect(second).toEqual(first);
-    expect(fetchMock).toHaveBeenCalledTimes(2);
-    nowSpy.mockRestore();
-  });
+      expect(second).toEqual(first);
+      expect(fetchMock).toHaveBeenCalledTimes(2);
+    }).pipe(Effect.provide(GitHubReleases.Live)),
+  );
 });

packages/workspace-server/src/services/github-releases/github-releases.test.ts

@@ -1,52 +1,97 @@
-import { injectable } from "inversify";
+import { Clock, Context, Effect, Layer, Ref, Result, Schema } from "effect";
 import { githubReleasesApiResponse, type ListReleasesOutput } from "./schemas";
 
 const RELEASES_URL =
   "https://api.github.com/repos/PostHog/code/releases?per_page=30";
 const CACHE_TTL_MS = 10 * 60_000;
 const FETCH_TIMEOUT_MS = 10_000;
 
-@injectable()
-export class GitHubReleasesService {
-  private cache: { fetchedAt: number; data: ListReleasesOutput } | null = null;
+export class GitHubReleasesError extends Schema.TaggedErrorClass<GitHubReleasesError>()(
+  "GitHubReleasesError",
+  { cause: Schema.Defect() },
+) {}
 
-  async listReleases(): Promise<ListReleasesOutput> {
-    if (this.cache && Date.now() - this.cache.fetchedAt < CACHE_TTL_MS) {
-      return this.cache.data;
-    }
+interface CachedReleases {
+  readonly fetchedAt: number;
+  readonly data: ListReleasesOutput;
+}
 
-    try {
-      const response = await fetch(RELEASES_URL, {
+const fetchReleases = Effect.fn("GitHubReleases.fetch")(function* () {
+  const response = yield* Effect.tryPromise({
+    try: () =>
+      fetch(RELEASES_URL, {
         headers: { Accept: "application/vnd.github+json" },
         signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
-      });
-      if (!response.ok) {
-        throw new Error(`GitHub releases fetch failed: ${response.status}`);
-      }
-
-      const parsed = githubReleasesApiResponse.parse(await response.json());
-      const releases = parsed
-        .filter((release) => !release.draft)
-        .map((release) => ({
-          version: release.tag_name.replace(/^v/, ""),
-          name:
-            release.name && release.name.length > 0
-              ? release.name
-              : release.tag_name,
-          notes: release.body ?? "",
-          date: release.published_at,
-          isPrerelease: release.prerelease,
-          htmlUrl: release.html_url,
-        }));
-
-      const data: ListReleasesOutput = { releases };
-      this.cache = { fetchedAt: Date.now(), data };
-      return data;
-    } catch (error) {
-      if (this.cache) {
-        return this.cache.data;
-      }
-      throw error;
-    }
+      }),
+    catch: (cause) => new GitHubReleasesError({ cause }),
+  });
+
+  if (!response.ok) {
+    return yield* Effect.fail(
+      new GitHubReleasesError({
+        cause: new Error(`GitHub releases fetch failed: ${response.status}`),
+      }),
+    );
   }
+
+  const json = yield* Effect.tryPromise({
+    try: () => response.json(),
+    catch: (cause) => new GitHubReleasesError({ cause }),
+  });
+  const parsed = yield* Effect.try({
+    try: () => githubReleasesApiResponse.parse(json),
+    catch: (cause) => new GitHubReleasesError({ cause }),
+  });
+
+  const releases = parsed
+    .filter((release) => !release.draft)
+    .map((release) => ({
+      version: release.tag_name.replace(/^v/, ""),
+      name:
+        release.name && release.name.length > 0
+          ? release.name
+          : release.tag_name,
+      notes: release.body ?? "",
+      date: release.published_at,
+      isPrerelease: release.prerelease,
+      htmlUrl: release.html_url,
+    }));
+
+  return { releases } satisfies ListReleasesOutput;
+});
+
+type ReleasesCache = Ref.Ref<CachedReleases | null>;
+
+const listReleases = Effect.fn("GitHubReleases.list")(function* (
+  cache: ReleasesCache,
+) {
+  const now = yield* Clock.currentTimeMillis;
+  const cached = yield* Ref.get(cache);
+  if (cached && now - cached.fetchedAt < CACHE_TTL_MS) {
+    return cached.data;
+  }
+
+  const result = yield* Effect.result(fetchReleases());
+  if (Result.isSuccess(result)) {
+    yield* Ref.set(cache, { fetchedAt: now, data: result.success });
+    return result.success;
+  }
+
+  // The refresh failed: serve the last good copy if we have one, else fail.
+  if (cached) {
+    return cached.data;
+  }
+  return yield* Effect.fail(result.failure);
+});
+
+export class GitHubReleases extends Context.Service<GitHubReleases>()(
+  "GitHubReleases",
+  {
+    make: Effect.gen(function* () {
+      const cache = yield* Ref.make<CachedReleases | null>(null);
+      return { list: () => listReleases(cache) };
+    }),
+  },
+) {
+  static Live = Layer.effect(this, this.make);
 }