Harden server async error handling with typed Effect errors

- Replace raw `Effect.promise`/generic errors with `Effect.tryPromise` and tagged schema errors - Improve orchestration harness/test reliability with explicit timeout/runtime error types - Tighten related tests and error assertions to match typed error flows

Julius Marminge committed 8 months ago

Commit 00cdf411 parent 1b982137 files · +121 −56Browse files

Unified · Split

7 files

apps/server/integration/OrchestrationEngineHarness.integration.ts +52 −27
apps/server/integration/orchestrationEngine.integration.test.ts +20 −3
apps/server/src/git/Layers/GitManager.test.ts +20 −15
apps/server/src/keybindings.test.ts +1 −7
apps/server/src/open.ts +4 −1
apps/server/src/terminal/Layers/NodePTY.ts +17 −2
apps/server/src/wsServer.ts +7 −1

apps/server/integration/OrchestrationEngineHarness.integration.ts+52−27

   type OrchestrationEvent,
   type OrchestrationThread,
 } from "@t3tools/contracts";
-import { Effect, Exit, Layer, ManagedRuntime, Option, Schedule, Scope, Stream } from "effect";
+import { Effect, Exit, Layer, ManagedRuntime, Option, Schedule, Schema, Scope, Stream } from "effect";
 import { CheckpointStoreLive } from "../src/checkpointing/Layers/CheckpointStore.ts";
 import { CheckpointStore } from "../src/checkpointing/Services/CheckpointStore.ts";
   return runGit(cwd, ["show", `${ref}:${filePath}`]);
 }
-function waitFor<A>(
+class WaitForTimeoutError extends Schema.TaggedErrorClass<WaitForTimeoutError>()("WaitForTimeoutError", {
-  read: Effect.Effect<A, unknown>,
+  description: Schema.String,
+}) {}
+function waitFor<A, E>(
+  read: Effect.Effect<A, E>,
   predicate: (value: A) => boolean,
   description: string,
   timeoutMs?: number,
 ): Effect.Effect<A, never>;
-function waitFor<A, B extends A>(
+function waitFor<A, B extends A, E>(
-  read: Effect.Effect<A, unknown>,
+  read: Effect.Effect<A, E>,
   predicate: (value: A) => value is B,
   description: string,
   timeoutMs?: number,
 ): Effect.Effect<B, never>;
-function waitFor<A>(
+function waitFor<A, E>(
-  read: Effect.Effect<A, unknown>,
+  read: Effect.Effect<A, E>,
   predicate: (value: A) => boolean,
   description: string,
   timeoutMs = 3000,
       while: (error) => error === RETRY_SIGNAL,
     }),
     Effect.mapError((error) =>
-      error === RETRY_SIGNAL ? new Error(`Timed out waiting for ${description}.`) : error,
+      error === RETRY_SIGNAL ? new WaitForTimeoutError({ description }) : error,
     ),
     Effect.orDie,
   );
 }
+class OrchestrationHarnessRuntimeError extends Schema.TaggedErrorClass<OrchestrationHarnessRuntimeError>()(
+  "OrchestrationHarnessRuntimeError",
+  {
+    operation: Schema.String,
+    cause: Schema.optional(Schema.Defect),
+  },
+) {}
+const tryRuntimePromise = <A>(operation: string, run: () => Promise<A>) =>
+  Effect.tryPromise({
+    try: run,
+    catch: (cause) => new OrchestrationHarnessRuntimeError({ operation, cause }),
+  });
 export interface OrchestrationIntegrationHarness {
   readonly rootDir: string;
   readonly workspaceDir: string;
 export const makeOrchestrationIntegrationHarness = Effect.gen(function* () {
   const sleep = (ms: number) =>
-    Effect.promise(() => new Promise<void>((resolve) => setTimeout(resolve, ms)));
+    Effect.tryPromise({
+      try: () => new Promise<void>((resolve) => setTimeout(resolve, ms)),
+      catch: (cause) => new OrchestrationHarnessRuntimeError({ operation: "sleep", cause }),
+    }).pipe(Effect.orDie);
   const adapterHarness = yield* makeTestProviderAdapterHarness;
   const rootDir = fs.mkdtempSync(path.join(os.tmpdir(), "t3-orchestration-integration-"));
   );
   const runtime = ManagedRuntime.make(layer);
-  const engine = yield* Effect.promise(() =>
+  const engine = yield* tryRuntimePromise("load OrchestrationEngine service", () =>
     runtime.runPromise(Effect.service(OrchestrationEngineService)),
-  );
+  ).pipe(Effect.orDie);
-  const reactor = yield* Effect.promise(() =>
+  const reactor = yield* tryRuntimePromise("load OrchestrationReactor service", () =>
     runtime.runPromise(Effect.service(OrchestrationReactor)),
-  );
+  ).pipe(Effect.orDie);
-  const snapshotQuery = yield* Effect.promise(() =>
+  const snapshotQuery = yield* tryRuntimePromise("load ProjectionSnapshotQuery service", () =>
     runtime.runPromise(Effect.service(ProjectionSnapshotQuery)),
-  );
+  ).pipe(Effect.orDie);
-  const providerService = yield* Effect.promise(() =>
+  const providerService = yield* tryRuntimePromise("load ProviderService service", () =>
     runtime.runPromise(Effect.service(ProviderService)),
-  );
+  ).pipe(Effect.orDie);
-  const checkpointStore = yield* Effect.promise(() =>
+  const checkpointStore = yield* tryRuntimePromise("load CheckpointStore service", () =>
     runtime.runPromise(Effect.service(CheckpointStore)),
-  );
+  ).pipe(Effect.orDie);
-  const checkpointRepository = yield* Effect.promise(() =>
+  const checkpointRepository = yield* tryRuntimePromise(
-    runtime.runPromise(Effect.service(ProjectionCheckpointRepository)),
+    "load ProjectionCheckpointRepository service",
-  );
+    () => runtime.runPromise(Effect.service(ProjectionCheckpointRepository)),
-  const pendingApprovalRepository = yield* Effect.promise(() =>
+  ).pipe(Effect.orDie);
-    runtime.runPromise(Effect.service(ProjectionPendingApprovalRepository)),
+  const pendingApprovalRepository = yield* tryRuntimePromise(
-  );
+    "load ProjectionPendingApprovalRepository service",
+    () => runtime.runPromise(Effect.service(ProjectionPendingApprovalRepository)),
+  ).pipe(Effect.orDie);
-  const scope = yield* Effect.promise(() => Effect.runPromise(Scope.make("sequential")));
+  const scope = yield* Scope.make("sequential");
-  yield* Effect.promise(() => runtime.runPromise(reactor.start.pipe(Scope.provide(scope))));
+  yield* tryRuntimePromise("start OrchestrationReactor", () =>
+    runtime.runPromise(reactor.start.pipe(Scope.provide(scope))),
+  ).pipe(Effect.orDie);
   yield* sleep(10);
   const waitForThread: OrchestrationIntegrationHarness["waitForThread"] = (

apps/server/integration/orchestrationEngine.integration.test.ts+20−3

   ThreadId,
 } from "@t3tools/contracts";
 import { assert, it } from "@effect/vitest";
-import { Effect, Exit, Option } from "effect";
+import { Effect, Exit, Option, Schema } from "effect";
 import type { TestTurnResponse } from "./TestProviderAdapter.integration.ts";
 import {
   return new Date().toISOString();
 }
+class IntegrationSleepError extends Schema.TaggedErrorClass<IntegrationSleepError>()(
+  "IntegrationSleepError",
+  {
+    cause: Schema.optional(Schema.Defect),
+  },
+) {}
+class IntegrationWaitTimeoutError extends Schema.TaggedErrorClass<IntegrationWaitTimeoutError>()(
+  "IntegrationWaitTimeoutError",
+  {
+    description: Schema.String,
+  },
+) {}
 const sleep = (ms: number) =>
-  Effect.promise(() => new Promise<void>((resolve) => setTimeout(resolve, ms)));
+  Effect.tryPromise({
+    try: () => new Promise<void>((resolve) => setTimeout(resolve, ms)),
+    catch: (cause) => new IntegrationSleepError({ cause }),
+  }).pipe(Effect.orDie);
 function waitForSync<A>(
   read: () => A,
         return value;
       }
       if (Date.now() >= deadline) {
-        return yield* Effect.die(new Error(`Timed out waiting for ${description}.`));
+        return yield* Effect.die(new IntegrationWaitTimeoutError({ description }));
       }
       yield* sleep(10);
     }

apps/server/src/git/Layers/GitManager.test.ts+20−15

 import * as NodeServices from "@effect/platform-node/NodeServices";
 import { it } from "@effect/vitest";
-import { Effect, FileSystem, Layer, PlatformError, Scope } from "effect";
+import { Effect, FileSystem, Layer, PlatformError, Schema, Scope } from "effect";
 import { expect } from "vitest";
-import { GitHubCliError, TextGenerationError } from "../Errors.ts";
+import { GitCommandError, GitHubCliError, TextGenerationError } from "../Errors.ts";
 import { type GitManagerShape } from "../Services/GitManager.ts";
 import {
   type GitHubCliShape,
 import { GitCoreLive } from "./GitCore.ts";
 import { makeGitManager } from "./GitManager.ts";
+class GitFixtureError extends Schema.TaggedErrorClass<GitFixtureError>()("GitFixtureError", {
+  message: Schema.String,
+  cause: Schema.optional(Schema.Defect),
+}) {}
 interface FakeGhScenario {
   prListSequence?: string[];
   createdPrUrl?: string;
   defaultBranch?: string;
-  failWith?: Error;
+  failWith?: GitFixtureError;
 }
 interface FakeGitTextGeneration {
     branch: string | null;
     stagedSummary: string;
     stagedPatch: string;
-  }) => Effect.Effect<{ subject: string; body: string }, unknown>;
+  }) => Effect.Effect<{ subject: string; body: string }, GitFixtureError>;
   generatePrContent: (input: {
     cwd: string;
     baseBranch: string;
     commitSummary: string;
     diffSummary: string;
     diffPatch: string;
-  }) => Effect.Effect<{ title: string; body: string }, unknown>;
+  }) => Effect.Effect<{ title: string; body: string }, GitFixtureError>;
 }
 function makeTempDir(
   allowNonZeroExit = false,
 ): Effect.Effect<
   { readonly code: number; readonly stdout: string; readonly stderr: string },
-  unknown,
+  GitCommandError,
   GitService
 > {
   return Effect.gen(function* () {
 function initRepo(
   cwd: string,
-): Effect.Effect<void, unknown, FileSystem.FileSystem | Scope.Scope | GitService> {
+): Effect.Effect<void, PlatformError.PlatformError | GitCommandError, FileSystem.FileSystem | Scope.Scope | GitService> {
   return Effect.gen(function* () {
     const fs = yield* FileSystem.FileSystem;
     yield* runGit(cwd, ["init", "--initial-branch=main"]);
 function createBareRemote(): Effect.Effect<
   string,
-  unknown,
+  PlatformError.PlatformError | GitCommandError,
   FileSystem.FileSystem | Scope.Scope | GitService
 > {
   return Effect.gen(function* () {
   };
 }
-const normalizeGhError = (error: Error): GitHubCliError => {
+const normalizeGhError = (error: GitFixtureError): GitHubCliError => {
   if (error.message.includes("Command not found: gh")) {
     return new GitHubCliError({
       operation: "execute",
       const { manager } = yield* makeManager({
         ghScenario: {
-          failWith: new Error("Command not found: gh"),
+          failWith: new GitFixtureError({ message: "Command not found: gh" }),
         },
       });
         action: "commit_push",
       }).pipe(
         Effect.flip,
-        Effect.map((error) => (error instanceof Error ? error.message : String(error))),
+        Effect.map((error) => error.message),
       );
       expect(errorMessage).toContain("detached HEAD");
     }),
       const { manager } = yield* makeManager({
         ghScenario: {
-          failWith: new Error("Command not found: gh"),
+          failWith: new GitFixtureError({ message: "Command not found: gh" }),
         },
       });
         action: "commit_push_pr",
       }).pipe(
         Effect.flip,
-        Effect.map((error) => (error instanceof Error ? error.message : String(error))),
+        Effect.map((error) => error.message),
       );
       expect(errorMessage).toContain("GitHub CLI (`gh`) is required");
     }),
       const { manager } = yield* makeManager({
         ghScenario: {
-          failWith: new Error("authentication failed"),
+          failWith: new GitFixtureError({ message: "authentication failed" }),
         },
       });
         action: "commit_push_pr",
       }).pipe(
         Effect.flip,
-        Effect.map((error) => (error instanceof Error ? error.message : String(error))),
+        Effect.map((error) => error.message),
       );
       expect(errorMessage).toContain("gh auth login");
     }),

apps/server/src/keybindings.test.ts+1−7

       });
       assert.isTrue(configState.keybindings.some((entry) => entry.command === "terminal.toggle"));
-      assert.isFalse(
+      assert.isFalse(configState.keybindings.some((entry) => String(entry.command) === "invalid.command"));
-        configState.keybindings.some(
-          (entry) =>
-            // @ts-expect-error - invalid command
-            entry.command === "invalid.command",
-        ),
-      );
       assert.deepEqual(configState.issues, [
         {
           kind: "keybindings.invalid-entry",

apps/server/src/open.ts+4−1

   });
 const make = Effect.gen(function* () {
-  const open = yield* Effect.promise(() => import("open"));
+  const open = yield* Effect.tryPromise({
+    try: () => import("open"),
+    catch: (cause) => new OpenError({ message: "failed to load browser opener", cause }),
+  });
   return {
     openBrowser: (target) =>

apps/server/src/terminal/Layers/NodePTY.ts+17−2

 import { createRequire } from "node:module";
-import { Effect, FileSystem, Layer, Path } from "effect";
+import { Effect, FileSystem, Layer, Path, Schema } from "effect";
 import { PtyAdapter, PtyAdapterShape, PtyExitEvent, PtyProcess } from "../Services/PTY";
 let didEnsureSpawnHelperExecutable = false;
+export class NodePtyAdapterError extends Schema.TaggedErrorClass<NodePtyAdapterError>()(
+  "NodePtyAdapterError",
+  {
+    message: Schema.String,
+    cause: Schema.optional(Schema.Defect),
+  },
+) {}
 const resolveNodePtySpawnHelperPath = Effect.gen(function* () {
   const requireForNodePty = createRequire(import.meta.url);
   const path = yield* Path.Path;
     const fs = yield* FileSystem.FileSystem;
     const path = yield* Path.Path;
-    const nodePty = yield* Effect.promise(() => import("node-pty"));
+    const nodePty = yield* Effect.tryPromise({
+      try: () => import("node-pty"),
+      catch: (cause) =>
+        new NodePtyAdapterError({
+          message: "failed to load node-pty module",
+          cause,
+        }),
+    });
     const ensureNodePtySpawnHelperExecutableCached = yield* Effect.cached(
       ensureNodePtySpawnHelperExecutable().pipe(

apps/server/src/wsServer.ts+7−1

       case WS_METHODS.projectsSearchEntries: {
         const body = stripRequestTag(request.body);
-        return yield* Effect.promise(() => searchWorkspaceEntries(body));
+        return yield* Effect.tryPromise({
+          try: () => searchWorkspaceEntries(body),
+          catch: (cause) =>
+            new RouteRequestError({
+              message: `Failed to search workspace entries: ${String(cause)}`,
+            }),
+        });
       }
       case WS_METHODS.shellOpenInEditor: {