@distilled.cloud/fly-io 1.0.0-rc.15 → 1.0.0-rc.17

package/src/protocol.ts

@@ -11,14 +11,19 @@ import {
   matchTypedError,
 } from "@distilled.cloud/core/protocol-http";
 import {
+  hasSensitiveMember,
   makeRestProtocol,
   unwrapRedactedDeep,
   wrapSensitive,
 } from "@distilled.cloud/core/protocol-rest";
-import { failIfStrict, validateResponse } from "@distilled.cloud/core/response-validation";
+import {
+  failUnlessLenient,
+  validateResponse,
+  withholdActual,
+} from "@distilled.cloud/core/response-validation";
 import { parseRetryAfterForStatus } from "@distilled.cloud/core/retry-after";
 /**
- * Fly.io protocols — Machines REST, UI-EX REST (MPG), GraphQL add-ons, and
+ * Fly.io protocols -- Machines REST, UI-EX REST (MPG), GraphQL add-ons, and
  * Sprites REST.
  *
  * Machines (`FlyIoProtocol`) is a plain bearer-token JSON API at
@@ -116,7 +121,7 @@ const spritesErrorEnvelope = (body: unknown) => {
   return { message, code };
 };
 
-const resolveFlyCreds = Effect.gen(function* () {
+const resolveFlyCreds = /*@__PURE__*/ Effect.gen(function* () {
   const resolve = yield* Credentials;
   return yield* resolve;
 });
@@ -127,11 +132,10 @@ const resolveFlyCreds = Effect.gen(function* () {
  * GetSecret in the same process; this service only changes headers:
  * omit `Authorization`, send `Connection: close`.
  */
-export class MachineIdentity extends Context.Service<MachineIdentity, true>()(
-  "FlyIoMachineIdentity",
-) {}
+export class MachineIdentity
+  extends /*@__PURE__*/ Context.Service<MachineIdentity, true>()("FlyIoMachineIdentity") {}
 
-const FlyIoProtocolRest: Layer.Layer<API.Protocol> = makeRestProtocol<Config>({
+const FlyIoProtocolRest: Layer.Layer<API.Protocol> = /*@__PURE__*/ makeRestProtocol<Config>({
   credentials: resolveFlyCreds,
   baseUrl: (creds) => creds.apiBaseUrl,
   headers: (creds) => ({
@@ -142,9 +146,9 @@ const FlyIoProtocolRest: Layer.Layer<API.Protocol> = makeRestProtocol<Config>({
   parseError: ({ body, cause }) => new FlyIoParseError({ body, cause }),
 });
 
-export const FlyIoProtocol: Layer.Layer<API.Protocol> = Layer.effect(
+export const FlyIoProtocol: Layer.Layer<API.Protocol> = /*@__PURE__*/ Layer.effect(
   API.Protocol,
-  Effect.gen(function* () {
+  /*@__PURE__*/ Effect.gen(function* () {
     const rest = yield* API.Protocol;
     return API.Protocol.of({
       encode: (args) =>
@@ -160,10 +164,10 @@ export const FlyIoProtocol: Layer.Layer<API.Protocol> = Layer.effect(
       decode: rest.decode,
     });
   }),
-).pipe(Layer.provide(FlyIoProtocolRest));
+).pipe(/*@__PURE__*/ Layer.provide(FlyIoProtocolRest));
 
 /** MPG UI-EX REST at `https://api.fly.io` with the Machines bearer token. */
-export const FlyApiProtocol: Layer.Layer<API.Protocol> = makeRestProtocol<Config>({
+export const FlyApiProtocol: Layer.Layer<API.Protocol> = /*@__PURE__*/ makeRestProtocol<Config>({
   credentials: resolveFlyCreds,
   baseUrl: () => DEFAULT_FLY_API_BASE_URL,
   headers: (creds) => ({
@@ -404,7 +408,7 @@ const mintOnce = (fly: Config) =>
     if (typeof token !== "string" || token.length === 0) {
       return yield* fail(
         new FlyIoParseError({
-          body: json ?? text,
+          body: "[REDACTED]",
           cause: "mint response missing token",
         }),
       );
@@ -413,8 +417,11 @@ const mintOnce = (fly: Config) =>
   });
 
 // Keyed by the Fly token itself: `Redacted` hashes and compares by value.
-const mintedTokens = MutableHashMap.empty<Redacted.Redacted<string>, Redacted.Redacted<string>>();
-const mintInFlight = MutableHashMap.empty<
+const mintedTokens = /*@__PURE__*/ MutableHashMap.empty<
+  Redacted.Redacted<string>,
+  Redacted.Redacted<string>
+>();
+const mintInFlight = /*@__PURE__*/ MutableHashMap.empty<
   Redacted.Redacted<string>,
   Deferred.Deferred<Redacted.Redacted<string>, Effect.Error<ReturnType<typeof mintOnce>>>
 >();
@@ -554,24 +561,32 @@ const decodeSpritesResponse = ({
     }
 
     // Strict mode checks the mapped body (or parsed exec frames) against the
-    // output schema.
+    // output schema. For an output with sensitive members, a non-JSON body
+    // fails in every mode and parse errors withhold the body.
+    const sensitive = hasSensitiveMember(outputAst);
+    const reported = sensitive ? "[REDACTED]" : (execFrames ?? (nonJson ? text : json));
+    if (nonJson && sensitive) {
+      return yield* fail(
+        new FlyIoParseError({
+          body: "[REDACTED]",
+          cause: "Invalid JSON response",
+        }),
+      );
+    }
     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,
-        }),
+        new FlyIoParseError({ body: reported, cause: sensitive ? withholdActual(cause) : cause }),
     ).pipe(Effect.catch(fail));
     return wrapSensitive(outputAst, mapped);
   });
 
 /** Sprites REST at `https://api.sprites.dev/v1`, minted from `FLY_API_TOKEN`. */
-export const SpritesProtocol: Layer.Layer<API.Protocol> = Layer.succeed(
+export const SpritesProtocol: Layer.Layer<API.Protocol> = /*@__PURE__*/ Layer.succeed(
   API.Protocol,
-  API.Protocol.of({
+  /*@__PURE__*/ API.Protocol.of({
     encode: (args) =>
       encodeSpritesRequest(args) as Effect.Effect<HttpClientRequest.HttpClientRequest>,
     decode: (args) => decodeSpritesResponse(args) as Effect.Effect<unknown>,
@@ -579,25 +594,25 @@ export const SpritesProtocol: Layer.Layer<API.Protocol> = Layer.succeed(
 );
 
 // =============================================================================
-// GraphQL add-ons (Tigris, Redis) — POST https://api.fly.io/graphql
+// GraphQL add-ons (Tigris, Redis) -- POST https://api.fly.io/graphql
 // =============================================================================
 
-const GraphQLError = Schema.Struct({
+const GraphQLError = /*@__PURE__*/ Schema.Struct({
   message: Schema.String,
-  path: Schema.optional(Schema.Array(Schema.Unknown)),
-  extensions: Schema.optional(
-    Schema.Struct({
-      code: Schema.optional(Schema.String),
+  path: /*@__PURE__*/ Schema.optional(/*@__PURE__*/ Schema.Array(Schema.Unknown)),
+  extensions: /*@__PURE__*/ Schema.optional(
+    /*@__PURE__*/ Schema.Struct({
+      code: /*@__PURE__*/ Schema.optional(Schema.String),
     }),
   ),
 });
 
-const GraphQLEnvelope = Schema.Struct({
-  data: Schema.optional(Schema.NullOr(Schema.Unknown)),
-  errors: Schema.optional(Schema.Array(GraphQLError)),
+const GraphQLEnvelope = /*@__PURE__*/ Schema.Struct({
+  data: /*@__PURE__*/ Schema.optional(/*@__PURE__*/ Schema.NullOr(Schema.Unknown)),
+  errors: /*@__PURE__*/ Schema.optional(/*@__PURE__*/ Schema.Array(GraphQLError)),
 });
 
-const decodeEnvelope = Schema.decodeUnknownOption(GraphQLEnvelope);
+const decodeEnvelope = /*@__PURE__*/ Schema.decodeUnknownOption(GraphQLEnvelope);
 
 const matchGraphqlError = (
   status: number,
@@ -715,12 +730,23 @@ const graphqlDecode = ({
       }
     }
 
+    // For an output with sensitive members, a non-JSON body fails in every
+    // mode and parse errors withhold the body.
+    const sensitive = hasSensitiveMember(outputAst);
     if (!parsed) {
       if (status >= 400) {
         return yield* matchGraphqlError(status, text, headers, errors);
       }
+      if (sensitive) {
+        return yield* fail(
+          new FlyIoParseError({
+            body: "[REDACTED]",
+            cause: "response body is not valid JSON",
+          }),
+        );
+      }
       // Lenient mode returns the body as read.
-      return yield* failIfStrict(
+      return yield* failUnlessLenient(
         new FlyIoParseError({
           body: text,
           cause: "response body is not valid JSON",
@@ -752,16 +778,21 @@ const graphqlDecode = ({
     }
     // Strict mode checks the payload at the response path against the
     // output schema.
-    return yield* validateResponse(
+    const validated = yield* validateResponse(
       outputAst,
       payload === undefined ? null : payload,
-      (cause) => new FlyIoParseError({ body: json, cause }),
+      (cause) =>
+        new FlyIoParseError({
+          body: sensitive ? "[REDACTED]" : json,
+          cause: sensitive ? withholdActual(cause) : cause,
+        }),
     ).pipe(Effect.catch(fail));
+    return wrapSensitive(outputAst, validated);
   });
 
-export const FlyGraphqlProtocol: Layer.Layer<API.Protocol> = Layer.succeed(
+export const FlyGraphqlProtocol: Layer.Layer<API.Protocol> = /*@__PURE__*/ Layer.succeed(
   API.Protocol,
-  API.Protocol.of({
+  /*@__PURE__*/ API.Protocol.of({
     encode: (args) => graphqlEncode(args) as Effect.Effect<HttpClientRequest.HttpClientRequest>,
     decode: graphqlDecode,
   }),

package/src/retry.ts

@@ -33,17 +33,19 @@ export {
 } from "@distilled.cloud/core/retry";
 
 /** Context tag for configuring retry behavior of FlyIo API calls. */
-export class Retry extends Context.Service<Retry, Policy>()("FlyIoRetry") {}
+export class Retry extends /*@__PURE__*/ Context.Service<Retry, Policy>()("FlyIoRetry") {}
 
 /** Provides a custom retry policy to every FlyIo API call below it. */
 export const policy = (optionsOrFactory: Policy) =>
   Effect.provide(Layer.succeed(Retry, optionsOrFactory));
 
 /** Disables all automatic retries. */
-export const none = Effect.provide(Layer.succeed(Retry, { while: () => false }));
+export const none = /*@__PURE__*/ Effect.provide(
+  /*@__PURE__*/ Layer.succeed(Retry, { while: () => false }),
+);
 
 /** Apply the throttling retry policy (retries throttling errors indefinitely). */
-export const throttling = policy(throttlingFactory);
+export const throttling = /*@__PURE__*/ policy(throttlingFactory);
 
 /** Apply the transient retry policy (retries all transient errors indefinitely). */
-export const transient = policy(transientFactory);
+export const transient = /*@__PURE__*/ policy(transientFactory);