refactor(api): cover the client sources with effect lint (CLI-2841) (#7309)

## TL;DR

brings `packages/api/src` and its tests under the effect lint

## whats introduced?

- `packages/api/src/**` joins the allow list, and the generated
`contracts.ts` stays out
- `SupabaseApiConfigError` and `SupabaseApiInputError` move to
`Data.TaggedError` with the same message, name, cause, json and printed
output, pinned by a new test, so two `apps/cli` call sites whose
failures include them now yield them directly
- `createApiClient` in `bun.ts` and `node.ts` chains its promise instead
of being `async`, still disposing the runtime before it rejects
- the src tests move to effect: `FileSystem` and `Path`, schema json
codecs, and `Effect.runPromise` bodies instead of `async` callbacks

## ref

- closes: CLI-2841

Author: 7ttp

.oxlintrc.effect.json

@@ -6,6 +6,7 @@
   },
   "ignorePatterns": [
     "**",
+    "!packages/api/src/**",
     "!packages/config/**",
     "!packages/stack/**",
     "!apps/cli/src/**",
@@ -16,6 +17,7 @@
     "apps/cli/src/shared/feedback/database.types.ts",
     "apps/cli/src/command-internal/db-bootstrap/local-db-running.integration.test.ts",
     "apps/cli/src/command-internal/db-bootstrap/local-db-running.ts",
+    "packages/api/src/generated/contracts.ts",
     "!apps/cli/tests/helpers/branches-live.ts",
     "!apps/cli/tests/helpers/compute.ts",
     "!apps/cli/tests/helpers/migration-live.ts",

apps/cli/src/command-internal/http-errors.ts

@@ -157,7 +157,7 @@ export function mapHttpError<N, S>(opts: {
       if (cause instanceof SupabaseApiInputError || cause instanceof HttpBody.HttpBodyError) {
         // Client-side validation/build failures: keep their identity, since
         // this generic mapper can't safely reclassify them as response errors.
-        return yield* Effect.fail(cause);
+        return yield* cause;
       }
       if (HttpClientError.isHttpClientError(cause)) {
         if (RESPONSE_ERROR_TAGS.has(cause.reason._tag) && cause.response !== undefined) {

apps/cli/src/commands/start/start.handler.ts

@@ -1851,7 +1851,7 @@ export const start = Effect.fn("start")(function* (flags: StartFlags) {
                 if (Result.isFailure(seedResult)) {
                   // No manual `rollbackStart` here — the outer
                   // `Effect.onError` below rolls back on this failure too.
-                  return yield* Effect.fail(seedResult.failure);
+                  return yield* seedResult.failure;
                 }
               }
             }

packages/api/src/bun-lifecycle.integration.test.ts

@@ -1,8 +1,9 @@
 import { describe, expect, test } from "vitest";
+import { Effect } from "effect";
 import { createApiClient } from "./bun.ts";
 
 describe("Bun client lifecycle", () => {
-  test("serves requests through the Bun entrypoint and rejects operations after disposal", async () => {
+  test("serves requests through the Bun entrypoint and rejects operations after disposal", () => {
     const paths: string[] = [];
     const server = Bun.serve({
       hostname: "127.0.0.1",
@@ -12,19 +13,27 @@ describe("Bun client lifecycle", () => {
         return Response.json([]);
       },
     });
-    const client = await createApiClient({
-      baseUrl: server.url.toString(),
-      accessToken: "test-token",
-    });
-    try {
-      await expect(client.v1.listAllProjects()).resolves.toEqual([]);
-      expect(paths).toEqual(["/v1/projects"]);
-      await client.dispose();
-      await expect(client.v1.listAllProjects()).rejects.toThrow();
-      expect(paths).toEqual(["/v1/projects"]);
-    } finally {
-      await client.dispose();
-      await server.stop(true);
-    }
+    return Effect.runPromise(
+      Effect.acquireUseRelease(
+        Effect.promise(() =>
+          createApiClient({
+            baseUrl: server.url.toString(),
+            accessToken: "test-token",
+          }),
+        ),
+        (client) =>
+          Effect.gen(function* () {
+            yield* Effect.promise(() => expect(client.v1.listAllProjects()).resolves.toEqual([]));
+            expect(paths).toEqual(["/v1/projects"]);
+            yield* Effect.promise(() => client.dispose());
+            yield* Effect.promise(() => expect(client.v1.listAllProjects()).rejects.toThrow());
+            expect(paths).toEqual(["/v1/projects"]);
+          }),
+        (client) =>
+          Effect.promise(() => client.dispose()).pipe(
+            Effect.andThen(Effect.promise(() => server.stop(true))),
+          ),
+      ),
+    );
   });
 });

packages/api/src/bun.ts

@@ -7,18 +7,15 @@ import { type SupabaseApiClientOptions, type SupabaseApiConfig } from "./interna
 import { makePromiseClient, type PromiseClient } from "./internal/promise-client.ts";
 
 /** Creates a Promise API client backed by a managed Bun runtime. */
-export async function createApiClient(
+export function createApiClient(
   config: SupabaseApiConfig = {},
   options?: SupabaseApiClientOptions,
 ): Promise<PromiseSupabaseApiClient> {
   const runtime = ManagedRuntime.make(Layer.mergeAll(BunServices.layer, FetchHttpClient.layer));
-  try {
-    const effectClient = await runtime.runPromise(makeApiClient(config, options));
-    return makePromiseClient(runtime, effectClient);
-  } catch (error) {
-    await runtime.dispose();
-    throw error;
-  }
+  return runtime
+    .runPromise(makeApiClient(config, options))
+    .then((effectClient) => makePromiseClient(runtime, effectClient))
+    .catch((error: unknown) => runtime.dispose().then(() => Promise.reject(error)));
 }
 
 /** Promise API client whose runtime resources are released by `dispose`. */

packages/api/src/config/api-config.layer.unit.test.ts

@@ -1,27 +1,29 @@
 import { describe, expect, test } from "vitest";
-import { ConfigProvider, Effect, Option } from "effect";
+import { ConfigProvider, Effect, Layer, Option } from "effect";
 
 import { apiConfigLayer, DEFAULT_SUPABASE_API_URL } from "./api-config.layer.ts";
 import { ApiConfig } from "./api-config.service.ts";
 
 describe("apiConfigLayer", () => {
-  test("defaults the API URL and reads the access token from config", async () => {
-    const config = await Effect.runPromise(
+  test("defaults the API URL and reads the access token from config", () =>
+    Effect.runPromise(
       Effect.gen(function* () {
-        return yield* ApiConfig;
-      }).pipe(
-        Effect.provide(apiConfigLayer),
-        Effect.provide(
-          ConfigProvider.layer(
-            ConfigProvider.fromUnknown({
-              SUPABASE_ACCESS_TOKEN: "env-token",
-            }),
+        const config = yield* Effect.service(ApiConfig).pipe(
+          Effect.provide(
+            apiConfigLayer.pipe(
+              Layer.provide(
+                ConfigProvider.layer(
+                  ConfigProvider.fromUnknown({
+                    SUPABASE_ACCESS_TOKEN: "env-token",
+                  }),
+                ),
+              ),
+            ),
           ),
-        ),
-      ),
-    );
+        );
 
-    expect(config.baseUrl).toBe(DEFAULT_SUPABASE_API_URL);
-    expect(Option.isSome(config.accessToken)).toBe(true);
-  });
+        expect(config.baseUrl).toBe(DEFAULT_SUPABASE_API_URL);
+        expect(Option.isSome(config.accessToken)).toBe(true);
+      }),
+    ));
 });