@distilled.cloud/fly-io 1.0.0-rc.11 → 1.0.0-rc.13

package/src/protocol.ts

@@ -19,16 +19,18 @@
  * `Authorization: Bearer` on sprite ops. There is no `SPRITES_TOKEN`.
  */
 import * as Context from "effect/Context";
+import * as Deferred from "effect/Deferred";
 import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import * as Redacted from "effect/Redacted";
 import * as Schema from "effect/Schema";
 import type * as AST from "effect/SchemaAST";
-import * as HttpClient from "effect/unstable/http/HttpClient";
-import type * as HttpClientError from "effect/unstable/http/HttpClientError";
-import * as HttpClientRequest from "effect/unstable/http/HttpClientRequest";
-import type * as HttpClientResponse from "effect/unstable/http/HttpClientResponse";
+import * as HttpClient from "effect/http/HttpClient";
+import type * as HttpClientError from "effect/http/HttpClientError";
+import * as HttpClientRequest from "effect/http/HttpClientRequest";
+import type * as HttpClientResponse from "effect/http/HttpClientResponse";
 import * as API from "@distilled.cloud/core/api";
 import {
   makeRestProtocol,
@@ -46,6 +48,10 @@ import {
   InternalServerError,
   type ConfigError,
 } from "@distilled.cloud/core/errors";
+import {
+  failIfStrict,
+  validateResponse,
+} from "@distilled.cloud/core/response-validation";
 import { parseRetryAfterForStatus } from "@distilled.cloud/core/retry-after";
 import {
   Credentials,
@@ -147,6 +153,7 @@ const FlyIoProtocolRest: Layer.Layer<API.Protocol> = makeRestProtocol<Config>({
   }),
   errorEnvelope: flyErrorEnvelope,
   unknownError: ({ message, body }) => new UnknownFlyIoError({ message, body }),
+  parseError: ({ body, cause }) => new FlyIoParseError({ body, cause }),
 });
 
 export const FlyIoProtocol: Layer.Layer<API.Protocol> = Layer.effect(
@@ -180,6 +187,7 @@ export const FlyApiProtocol: Layer.Layer<API.Protocol> =
     errorEnvelope: flyErrorEnvelope,
     unknownError: ({ message, body }) =>
       new UnknownFlyIoError({ message, body }),
+    parseError: ({ body, cause }) => new FlyIoParseError({ body, cause }),
   });
 
 const parseMaybeNdjson = (body: unknown): unknown => {
@@ -432,34 +440,42 @@ const mintOnce = (fly: Config) =>
         }),
       );
     }
-    // Cache the raw string — Effect.cached must not hold a Redacted (the
-    // registry entry is not restored from a memoized Exit).
+    // Cache the raw string, not a Redacted whose registry entry may be erased.
     return token;
   });
 
 const mintedTokens = new Map<string, string>();
-const mintInFlight = new Map<string, ReturnType<typeof mintOnce>>();
+const mintInFlight = new Map<
+  string,
+  Deferred.Deferred<string, Effect.Error<ReturnType<typeof mintOnce>>>
+>();
 
 /** Mint (and process-wide cache) a Sprites bearer from `FLY_API_TOKEN`. */
 const mintSpritesToken = (fly: Config) =>
-  Effect.gen(function* () {
-    const key = Redacted.value(fly.apiKey);
-    const hit = mintedTokens.get(key);
-    if (hit !== undefined) return hit;
-    const pending = mintInFlight.get(key);
-    if (pending !== undefined) return yield* pending;
-    const run = mintOnce(fly).pipe(
-      Effect.tap((token) =>
-        Effect.sync(() => {
-          mintedTokens.set(key, token);
-          mintInFlight.delete(key);
-        }),
-      ),
-      Effect.tapError(() => Effect.sync(() => mintInFlight.delete(key))),
-    );
-    mintInFlight.set(key, run);
-    return yield* run;
-  });
+  Effect.uninterruptibleMask((restore) =>
+    Effect.suspend(() => {
+      const key = Redacted.value(fly.apiKey);
+      const hit = mintedTokens.get(key);
+      if (hit !== undefined) return Effect.succeed(hit);
+      const pending = mintInFlight.get(key);
+      if (pending !== undefined) return restore(Deferred.await(pending));
+      const result = Deferred.makeUnsafe<
+        string,
+        Effect.Error<ReturnType<typeof mintOnce>>
+      >();
+      mintInFlight.set(key, result);
+      return restore(mintOnce(fly)).pipe(
+        Effect.onExit((exit) =>
+          Effect.gen(function* () {
+            if (Exit.isSuccess(exit)) mintedTokens.set(key, exit.value);
+            // Release all waiters, including on defects and owner interruption.
+            mintInFlight.delete(key);
+            yield* Deferred.done(result, exit);
+          }),
+        ),
+      );
+    }),
+  );
 
 const encodeSpritesRequest = ({
   input,
@@ -527,12 +543,17 @@ const decodeSpritesResponse = ({
       ) {
         return yield* fail(new SpritesNotEnabled({ message }));
       }
-      const typed = matchTypedError(errorClasses, status, [
-        {
-          code: typeof env.code === "number" ? env.code : undefined,
-          message,
-        },
-      ]);
+      const typed = matchTypedError(
+        errorClasses,
+        status,
+        [
+          {
+            code: typeof env.code === "number" ? env.code : undefined,
+            message,
+          },
+        ],
+        { body: nonJson ? text : json, headers },
+      );
       if (typed !== undefined) return yield* fail(typed);
 
       const StatusErrorClass = (HTTP_STATUS_MAP as Record<number, unknown>)[
@@ -567,13 +588,20 @@ const decodeSpritesResponse = ({
       );
     }
 
-    if (execFrames !== undefined) {
-      return wrapSensitive(outputAst, mapKeys(outputAst, execFrames, "decode"));
-    }
-
-    let body: unknown = nonJson ? text : (json ?? {});
-    body = parseMaybeNdjson(body);
-    return wrapSensitive(outputAst, mapKeys(outputAst, body, "decode"));
+    // Strict mode checks the mapped body (or parsed exec frames) against the
+    // output schema.
+    const body: unknown =
+      execFrames ?? parseMaybeNdjson(nonJson ? text : (json ?? {}));
+    const mapped = yield* validateResponse(
+      outputAst,
+      mapKeys(outputAst, body, "decode"),
+      (cause) =>
+        new FlyIoParseError({
+          body: execFrames ?? (nonJson ? text : json),
+          cause,
+        }),
+    ).pipe(Effect.catch(fail));
+    return wrapSensitive(outputAst, mapped);
   });
 
 /** Sprites REST at `https://api.sprites.dev/v1`, minted from `FLY_API_TOKEN`. */
@@ -619,7 +647,10 @@ const matchGraphqlError = (
   if (envelope._tag === "Some" && envelope.value.errors?.length) {
     const first = envelope.value.errors[0]!;
     const message = first.message;
-    const typed = matchTypedError(errorClasses, status, [{ message }]);
+    const typed = matchTypedError(errorClasses, status, [{ message }], {
+      body: errorBody,
+      headers,
+    });
     if (typed !== undefined) return fail(typed);
     if (
       /not authorized to access this createextensiontosagreement/i.test(message)
@@ -730,12 +761,14 @@ const graphqlDecode = ({
       if (status >= 400) {
         return yield* matchGraphqlError(status, text, headers, errors);
       }
-      return yield* fail(
+      // Lenient mode returns the body as read.
+      return yield* failIfStrict(
         new FlyIoParseError({
           body: text,
           cause: "response body is not valid JSON",
         }),
-      );
+        text,
+      ).pipe(Effect.catch(fail));
     }
 
     const envelope = json as { data?: unknown; errors?: unknown[] } | null;
@@ -761,7 +794,13 @@ const graphqlDecode = ({
             : undefined;
       }
     }
-    return payload === undefined ? null : payload;
+    // Strict mode checks the payload at the response path against the
+    // output schema.
+    return yield* validateResponse(
+      outputAst,
+      payload === undefined ? null : payload,
+      (cause) => new FlyIoParseError({ body: json, cause }),
+    ).pipe(Effect.catch(fail));
   });
 
 export const FlyGraphqlProtocol: Layer.Layer<API.Protocol> = Layer.succeed(

package/src/response-validation.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, test } from "bun:test";
+import { runValidationModes } from "@distilled.cloud/core/testing";
+import * as Effect from "effect/Effect";
+import { credentials } from "./credentials.ts";
+import { FlyIoParseError } from "./errors.ts";
+import * as Retry from "./retry.ts";
+import { listApps } from "./services/machines.ts";
+import type { FlyIoOpError } from "./protocol.ts";
+
+// listApps (Machines REST) declares `{ apps?: App[]; total_apps?: number }`.
+const run = (body: string) =>
+  runValidationModes(
+    listApps({ org_slug: "personal" }).pipe(
+      Retry.none,
+      Effect.provide(credentials({ apiKey: "test" })),
+    ),
+    { body },
+  );
+
+describe("Fly.io Machines response validation", () => {
+  test("a matching body succeeds unchanged in both modes", async () => {
+    const body = { apps: [{ id: "app-1", name: "my-app" }], total_apps: 1 };
+    const { lenient, strict } = await run(JSON.stringify(body));
+    expect(lenient).toMatchObject({ _tag: "Success", success: body });
+    expect(strict).toMatchObject({ _tag: "Success", success: body });
+  });
+
+  test("a member with the wrong type: lenient returns it, strict fails", async () => {
+    const body = { apps: [], total_apps: "one" };
+    const { lenient, strict } = await run(JSON.stringify(body));
+    expect(lenient).toMatchObject({ _tag: "Success", success: body });
+    expect(strict._tag).toBe("Failure");
+    expect((strict as any).failure).toBeInstanceOf(FlyIoParseError);
+  });
+
+  test("a non-JSON body: lenient returns the text, strict fails", async () => {
+    const { lenient, strict } = await run("not json");
+    expect(lenient).toMatchObject({ _tag: "Success", success: "not json" });
+    expect((strict as any).failure).toBeInstanceOf(FlyIoParseError);
+  });
+});
+
+// FlyIoParseError is part of every operation's declared error type.
+export const parseErrorIsDeclared: [FlyIoParseError] extends [FlyIoOpError]
+  ? true
+  : false = true;