@homeflare/distilled-proxmox-backup 0.2.0

package/src/errors.ts

@@ -0,0 +1,126 @@
+/**
+ * Proxmox Backup Server-specific error types.
+ *
+ * Ported from `packages/proxmox/src/errors.ts` in this same distilled
+ * clone, with one deliberate omission — see the ⛔ below.
+ *
+ * ⛔ NO `ClusterNodeUnreachable`, NO `patches/nodes/task-polling.json`.
+ *   PVE's version of this file adds a `ClusterNodeUnreachable` (HTTP 595)
+ *   error via an RFC-6902 patch to the four `/nodes/{node}/tasks/…`
+ *   operations the VENDOR SCHEMA marks `proxyto: "node"` (PVE forwards a
+ *   request to whichever cluster member actually owns the task). MEASURED:
+ *   the pinned PBS schema (`~/.cache/homeflare/schemas/proxmox/
+ *   pbs_4.2.6-1_apidoc.js`) has ZERO occurrences of `"proxyto"` anywhere —
+ *   `grep -c '"proxyto"'` on the full 1.5 MB file returns 0. This is
+ *   expected, not a gap: PBS is a single-host backup datastore product,
+ *   not a cluster, so there is nothing for a request to be forwarded to.
+ *   Carrying the 595 error and its patch forward would assert a failure
+ *   mode the vendor schema gives no evidence for. `src/task.ts`'s
+ *   `awaitTask` here therefore has a narrower error union than PVE's.
+ */
+export {
+  BadGateway,
+  BadRequest,
+  Conflict,
+  ConfigError,
+  Forbidden,
+  GatewayTimeout,
+  InternalServerError,
+  Locked,
+  NotFound,
+  ServiceUnavailable,
+  TooManyRequests,
+  Unauthorized,
+  UnprocessableEntity,
+  HTTP_STATUS_MAP,
+  DEFAULT_ERRORS,
+  API_ERRORS,
+} from "@distilled.cloud/core/errors";
+// `export { X } from "mod"` (above) is a RE-EXPORT ONLY — it creates no local
+// binding for `X`, so `BadRequest` needs its own `import type` to be usable
+// in this file's own `DefaultErrors` union below.
+import type {
+  BadRequest,
+  DefaultErrors as CoreDefaultErrors,
+} from "@distilled.cloud/core/errors";
+
+import * as Schema from "effect/Schema";
+import * as Category from "@distilled.cloud/core/category";
+
+/**
+ * PBS's generic parameter-validation failure: `400` with `{"data":null,
+ * "errors":{"<param>":"<message>", …}, "message":"parameter verification
+ * failed"}`. ⚠️ NOT INDEPENDENTLY MEASURED AGAINST A LIVE PBS HOST (this
+ * build makes no live PBS calls). Carried forward from PVE's identical,
+ * measured shape on the strength of same-vendor architecture: PBS's own
+ * api-viewer/apidoc.js is the same schema-driven tooling PVE's is (the
+ * `apidoc.ts` parser in this package reads both with only a declaration-
+ * syntax and terminator difference — see that file's header), and
+ * `taslabs-net/homeflare-kit`'s `packages/alchemy/src/proxmox/
+ * credentials.ts` documents PBS and PVE as literally sharing one HTTP
+ * client because "PBS is the same client with a different Authorization
+ * header" — i.e. the `{"data": …}` envelope and error shape are asserted
+ * identical there too, also without a live PBS credential to confirm
+ * against. Flagged here as INFERRED, not measured, so a future caller who
+ * DOES get a live token knows to re-check this specific claim first.
+ */
+export class ParameterVerificationFailed extends Schema.TaggedError<ParameterVerificationFailed>()(
+  "ParameterVerificationFailed",
+  {
+    message: Schema.String,
+    errors: Schema.Record(Schema.String, Schema.String),
+  },
+).pipe(Category.withBadRequestError) {}
+
+/**
+ * Unknown Proxmox Backup Server error — returned when a failed response's
+ * HTTP status has no mapped error class. Carries the raw body for later
+ * cataloging.
+ */
+export class UnknownProxmoxBackupError extends Schema.TaggedError<UnknownProxmoxBackupError>()(
+  "UnknownProxmoxBackupError",
+  {
+    status: Schema.optional(Schema.Number),
+    message: Schema.optional(Schema.String),
+    body: Schema.Unknown,
+  },
+).pipe(Category.withServerError) {}
+
+/** Schema parse error wrapper. */
+export class ProxmoxBackupParseError extends Schema.TaggedError<ProxmoxBackupParseError>()(
+  "ProxmoxBackupParseError",
+  {
+    body: Schema.Unknown,
+    cause: Schema.Unknown,
+  },
+).pipe(Category.withParseError) {}
+
+/**
+ * A polled task ended with an `exitstatus` other than exactly `"OK"` — see
+ * `src/task.ts`. `exitstatus` carries PBS's own failure text verbatim.
+ */
+export class ProxmoxBackupTaskFailed extends Schema.TaggedError<ProxmoxBackupTaskFailed>()(
+  "ProxmoxBackupTaskFailed",
+  {
+    node: Schema.String,
+    upid: Schema.String,
+    exitstatus: Schema.String,
+  },
+) {}
+
+/**
+ * Errors any Proxmox Backup Server operation may surface in addition to
+ * the per-operation typed status errors.
+ */
+export type ClientErrors = UnknownProxmoxBackupError | ProxmoxBackupParseError;
+
+/**
+ * Default Proxmox Backup Server operation errors: the shared HTTP status
+ * errors from core, PBS's global parameter-verification failure, plus the
+ * client-level fallback/decode errors.
+ */
+export type DefaultErrors =
+  | CoreDefaultErrors
+  | BadRequest
+  | ParameterVerificationFailed
+  | ClientErrors;

package/src/index.ts

@@ -0,0 +1,36 @@
+/**
+ * @distilled.cloud/proxmox-backup — Proxmox Backup Server API SDK for
+ * Effect.
+ *
+ * `./services` is generated by `scripts/generate.ts` from the Smithy
+ * models in `.generated-specs` (written by `scripts/convert.ts` from PBS's
+ * own `apidoc.js`, mirrored under `specs/`). Everything else in this
+ * folder is hand-written.
+ *
+ * One module per PBS top-level path segment — `access`, `admin`, `backup`,
+ * `config`, `nodes`, `ping`, `pull`, `push`, `reader`, `root`, `status`,
+ * `tape`, `version` — the same split the vendor's own api-viewer uses
+ * (measured on the pinned schema; see `scripts/convert.ts`'s header for
+ * per-bucket endpoint counts).
+ *
+ * @example
+ * ```ts
+ * import * as ProxmoxBackup from "@distilled.cloud/proxmox-backup";
+ *
+ * const status = yield* ProxmoxBackup.Services.nodes.getNodeTaskStatus({
+ *   node: "pbs1",
+ *   upid: "UPID:pbs1:00001234:...",
+ * });
+ * ```
+ */
+export * from "./credentials.ts";
+export * from "./errors.ts";
+export * as T from "./traits.ts";
+export {
+  ProxmoxBackupProtocol,
+  type ProxmoxBackupOpError,
+  type ProxmoxBackupOpContext,
+} from "./protocol.ts";
+export * as Retry from "./retry.ts";
+export * as Services from "./services/index.ts";
+export { awaitTask, type TaskRef, type AwaitTaskOptions } from "./task.ts";

package/src/protocol.test.ts

@@ -0,0 +1,128 @@
+/**
+ * Ported from `packages/proxmox/src/protocol.test.ts` in this same
+ * distilled clone — same bug class, same shape: a bare 400 (no `errors`
+ * object) must decode to the non-retryable `BadRequest`, never the
+ * `Category.withServerError`-tagged `UnknownProxmoxBackupError`. See
+ * `protocol.ts`'s `unknownError` and `errors.ts`'s module header.
+ *
+ * Adds one test PVE's file does not need: the auth header itself, because
+ * that is the one thing measurably different between the two packages
+ * (`PBSAPIToken=<id>:<secret>`, colon separator — see `credentials.ts`'s
+ * header) and a wrong separator fails SILENTLY AS A 401 with no other
+ * symptom, per that same header's citation of the kit's own warning. All
+ * of this runs against a fake `HttpClient` — no live PBS host is
+ * contacted anywhere in this file.
+ */
+import { describe, expect, test } from "bun:test";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import * as HttpClientResponse from "effect/unstable/http/HttpClientResponse";
+import { credentials } from "./credentials.ts";
+import {
+  BadRequest,
+  ParameterVerificationFailed,
+  UnknownProxmoxBackupError,
+} from "./errors.ts";
+import * as Retry from "./retry.ts";
+import { getVersion } from "./services/version.ts";
+
+const testCredentials = credentials({
+  tokenId: "backup@pbs!test",
+  secret: "test-secret",
+  baseUrl: "https://pbs.test:8007",
+});
+
+const fakePbs = (status: number, body: unknown) =>
+  Layer.succeed(
+    HttpClient.HttpClient,
+    HttpClient.make((request) =>
+      Effect.sync(() =>
+        HttpClientResponse.fromWeb(
+          request,
+          new Response(JSON.stringify(body), { status }),
+        ),
+      ),
+    ),
+  );
+
+const call = (status: number, body: unknown) =>
+  Effect.runPromise(
+    getVersion({}).pipe(
+      Retry.none,
+      Effect.provide(Layer.mergeAll(fakePbs(status, body), testCredentials)),
+      Effect.flip,
+    ),
+  );
+
+describe("protocol.ts error decoding", () => {
+  test("a bare 400 (no `errors` object) is BadRequest, never UnknownProxmoxBackupError", async () => {
+    const error = await call(400, { data: null, message: "invalid parameter" });
+    expect(error).toBeInstanceOf(BadRequest);
+    expect(error).not.toBeInstanceOf(UnknownProxmoxBackupError);
+    expect(error).toMatchObject({ message: "invalid parameter" });
+  });
+
+  test("a 400 with an `errors` object is ParameterVerificationFailed, carrying the per-field messages", async () => {
+    const error = await call(400, {
+      data: null,
+      message: "parameter verification failed",
+      errors: { comment: "value may only be 128 characters long" },
+    });
+    expect(error).toBeInstanceOf(ParameterVerificationFailed);
+    expect(error).toMatchObject({
+      message: "parameter verification failed",
+      errors: { comment: "value may only be 128 characters long" },
+    });
+  });
+
+  test("a genuinely unmapped, non-5xx status still falls back to UnknownProxmoxBackupError", async () => {
+    const error = await call(418, { data: null, message: "weird" });
+    expect(error).toBeInstanceOf(UnknownProxmoxBackupError);
+  });
+
+  test('the {"data": ...} envelope is unwrapped before decode', async () => {
+    const result = await Effect.runPromise(
+      getVersion({}).pipe(
+        Effect.provide(
+          Layer.mergeAll(
+            fakePbs(200, {
+              data: { version: "4.2.6", release: "4.2", repoid: "abc123" },
+            }),
+            testCredentials,
+          ),
+        ),
+      ),
+    );
+    expect(result).toMatchObject({ version: "4.2.6", release: "4.2" });
+  });
+});
+
+describe("credentials.ts auth header", () => {
+  test("Authorization is PBSAPIToken=<id>:<secret> — colon, never `=` like PVE's PVEAPIToken", async () => {
+    let seenAuth: string | undefined;
+    const capturing = Layer.succeed(
+      HttpClient.HttpClient,
+      HttpClient.make((request) =>
+        Effect.sync(() => {
+          seenAuth = request.headers["authorization"];
+          return HttpClientResponse.fromWeb(
+            request,
+            new Response(
+              JSON.stringify({
+                data: { version: "4.2.6", release: "4.2", repoid: "abc" },
+              }),
+              { status: 200 },
+            ),
+          );
+        }),
+      ),
+    );
+    await Effect.runPromise(
+      getVersion({}).pipe(
+        Effect.provide(Layer.mergeAll(capturing, testCredentials)),
+      ),
+    );
+    expect(seenAuth).toBe("PBSAPIToken=backup@pbs!test:test-secret");
+  });
+});

package/src/protocol.ts

@@ -0,0 +1,196 @@
+/**
+ * ProxmoxBackupProtocol — the shared bearer-REST protocol instantiated for
+ * Proxmox Backup Server. Hand-written; `@distilled.cloud/core` is never
+ * changed for a provider's own quirks — they all live here.
+ *
+ * Ported from `packages/proxmox/src/protocol.ts` in this same distilled
+ * clone. Three of PVE's "THREE 200-TRAPS" carry forward; the fourth
+ * (cluster-forwarding 595) does not exist for PBS — see `src/errors.ts`'s
+ * header. Each trap below cites what was actually checked against the
+ * pinned schema (`~/.cache/homeflare/schemas/proxmox/
+ * pbs_4.2.6-1_apidoc.js`), versus what is carried by same-vendor
+ * architecture and NOT independently measured (this build makes no live
+ * PBS calls).
+ *
+ * ## The envelope
+ *
+ * Every PBS response is wrapped `{"data": …}`, the same as PVE.
+ * ⚠️ NOT independently measured live (no PBS credential exists to call
+ * with). Asserted, not just assumed: `taslabs-net/homeflare-kit`'s
+ * `packages/alchemy/src/proxmox/credentials.ts` documents PVE and PBS
+ * sharing ONE http client specifically BECAUSE "Proxmox Backup Server
+ * speaks the same `/api2/json` paths, wraps every answer in the same
+ * `{"data": …}` envelope" — also written before that repo had a live PBS
+ * credential, so this is the same vendor-architecture inference stated
+ * independently in two places, not two confirmations of one live check.
+ * `transformResponse` below unwraps it before `core/protocol-rest`'s
+ * schema-driven decode ever sees a payload, exactly as PVE's does.
+ *
+ * ## Authentication
+ *
+ * The API-token scheme: `Authorization: PBSAPIToken=<user>@<realm>!
+ * <tokenid>:<secret>` — MEASURED DIFFERENT FROM PVE: a colon separator,
+ * not `=`, and a `PBSAPIToken` prefix, not `PVEAPIToken`. See
+ * `src/credentials.ts`'s header for the two independent citations (kit
+ * `credentials.ts` and `pbs-prune-job.ts`) and their shared caveat
+ * (reasoned from PBS's documented scheme, not a live call either).
+ *
+ * ## THE TRAPS CARRIED FROM PVE (measured against the pinned schema)
+ *
+ * (a) **Async POST/PUT/DELETE answer 200 with a UPID and can fail later.**
+ *     CONFIRMED IN SCHEMA: the pinned file's `pattern` for UPID-shaped
+ *     strings appears 44 times, and `GET /nodes/{node}/tasks/{upid}/status`
+ *     exists (measured: `grep -n 'tasks/{upid}/status'` finds it at line
+ *     25814) — the identical path shape PVE's own `awaitTask` polls.
+ *     Handled with real code: `src/task.ts`'s `awaitTask`, unchanged in
+ *     its `"OK"` exact-equality logic from PVE's (see that file's header
+ *     for why `"OK (warnings)"` must not match a prefix/substring check).
+ *
+ * (b) **Some PUTs answer 200 `{"data":null}` even when nothing changed.**
+ *     CONFIRMED IN SCHEMA: e.g. `PUT /access/acl` and `PUT /access/
+ *     password` both declare `"returns": {"type": "null"}` (measured,
+ *     among 53 total PUT endpoints in the pinned schema) — the same
+ *     declared-null-return signature PVE's update endpoints carry. THIS IS
+ *     NOT SOMETHING A PROTOCOL LAYER CAN DETECT OR FIX; documented here so
+ *     it travels with the protocol.
+ *
+ * (c) **Permission-filtered lists return 200 + `[]` instead of 403.**
+ *     CONFIRMED IN SCHEMA: `GET /access/acl`'s own `permissions.description`
+ *     reads "Returns all ACLs if user has Sys.Audit on '/access/acl', or
+ *     just the ACLs containing the user's API tokens" (measured, line 32
+ *     of the pinned file) — the identical conditional-visibility-by-token
+ *     phrasing the PVE package's header cites for this trap, not a guess
+ *     by analogy. Also undetectable here for the same reason as (b).
+ *
+ * ## NOT carried: cluster-forwarding 595
+ *
+ * See `src/errors.ts`'s header — the pinned schema has zero `proxyto`
+ * occurrences. PBS is not a cluster product.
+ *
+ * ## Self-signed TLS
+ *
+ * Same as PVE: explicitly not handled here or anywhere in this package —
+ * the `HttpClient.HttpClient` layer the caller provides owns that
+ * decision.
+ */
+import * as Effect from "effect/Effect";
+import type * as Layer from "effect/Layer";
+import * as Redacted from "effect/Redacted";
+import type * as HttpClient from "effect/unstable/http/HttpClient";
+import type * as HttpClientError from "effect/unstable/http/HttpClientError";
+import type * as API from "@distilled.cloud/core/api";
+import {
+  BadRequest,
+  HTTP_STATUS_MAP,
+  type ConfigError,
+} from "@distilled.cloud/core/errors";
+import {
+  makeRestProtocol,
+  type RestErrorEnvelope,
+} from "@distilled.cloud/core/protocol-rest";
+import { Credentials, type Config } from "./credentials.ts";
+import {
+  ParameterVerificationFailed,
+  UnknownProxmoxBackupError,
+  type DefaultErrors,
+} from "./errors.ts";
+
+/**
+ * Error channel shared by every generated Proxmox Backup Server operation.
+ * Generated service files annotate operations with
+ * `API.OperationMethod<I, O, ProxmoxBackupOpError, ProxmoxBackupOpContext>`
+ * explicitly so the compiler never infers these back out of the schema
+ * generics.
+ */
+export type ProxmoxBackupOpError =
+  | DefaultErrors
+  | ConfigError
+  | HttpClientError.HttpClientError;
+
+/** Context (requirements) shared by every generated Proxmox Backup Server operation. */
+export type ProxmoxBackupOpContext = Credentials | HttpClient.HttpClient;
+
+/**
+ * PBS's failure envelope is `{"data": null, "message": "...", "errors"?:
+ * {…}}` — see PVE's identical `errorEnvelope` for why `message` alone is
+ * read here (the `errors` sub-object is read straight from the body in
+ * `unknownError` below, never here).
+ */
+const errorEnvelope = (body: unknown): RestErrorEnvelope | undefined => {
+  if (body === null || typeof body !== "object") return undefined;
+  const b = body as Record<string, unknown>;
+  return { message: typeof b.message === "string" ? b.message : undefined };
+};
+
+/**
+ * `HTTP_STATUS_MAP` minus 400 — same reasoning as PVE's copy: PBS's 400 is
+ * specifically the parameter-verification failure, and the generic
+ * `BadRequest` would throw away the per-field `errors` object.
+ */
+const PROXMOX_BACKUP_STATUS_MAP: Record<number, new (args: any) => unknown> = {
+  ...HTTP_STATUS_MAP,
+};
+delete (PROXMOX_BACKUP_STATUS_MAP as Record<number, unknown>)[400];
+
+export const ProxmoxBackupProtocol: Layer.Layer<API.Protocol> =
+  makeRestProtocol<Config>({
+    credentials: Effect.gen(function* () {
+      const resolve = yield* Credentials;
+      return yield* resolve;
+    }),
+    baseUrl: (creds) => creds.apiBaseUrl,
+    headers: (creds) => ({
+      // ⛔ COLON, NOT `=` — see the module header's Authentication section.
+      Authorization: `PBSAPIToken=${creds.tokenId}:${Redacted.value(creds.secret)}`,
+      Accept: "application/json",
+    }),
+    errorEnvelope,
+    statusMap: PROXMOX_BACKUP_STATUS_MAP,
+    // Unwrap PBS's `{"data": …}` envelope BEFORE the schema-driven decode —
+    // see the module header. `data` is `null`/absent for a Unit-output
+    // operation; `?? {}` is core's own convention for "no body".
+    transformResponse: (body) => {
+      if (
+        body !== null &&
+        typeof body === "object" &&
+        "data" in (body as Record<string, unknown>)
+      ) {
+        return (body as Record<string, unknown>).data ?? {};
+      }
+      return body;
+    },
+    // Reached for a 400 (see PROXMOX_BACKUP_STATUS_MAP above) or a status
+    // with no core mapping at all. `body` is the FULL parsed failure
+    // envelope, so this is where PBS's per-field `errors` object is read.
+    //
+    // ⛔ A BARE 400 WITHOUT THE `errors` OBJECT MUST NOT FALL INTO
+    //   `UnknownProxmoxBackupError` — same retry-amplification hazard
+    //   PVE's identical comment explains (`ServerError` is retried
+    //   automatically; a malformed request is permanent). `BadRequest`
+    //   (`Category.withBadRequestError`, not retryable) is the honest
+    //   answer for "PBS said 400 and gave no further structure".
+    unknownError: ({ status, message, body }) => {
+      const b =
+        body !== null && typeof body === "object"
+          ? (body as Record<string, unknown>)
+          : undefined;
+      const fieldErrors = b?.errors;
+      if (status === 400) {
+        if (
+          fieldErrors !== null &&
+          typeof fieldErrors === "object" &&
+          !Array.isArray(fieldErrors)
+        ) {
+          const errors: Record<string, string> = {};
+          for (const [k, v] of Object.entries(
+            fieldErrors as Record<string, unknown>,
+          )) {
+            if (typeof v === "string") errors[k] = v;
+          }
+          return new ParameterVerificationFailed({ message, errors });
+        }
+        return new BadRequest({ message });
+      }
+      return new UnknownProxmoxBackupError({ status, message, body });
+    },
+  });

package/src/retry.ts

@@ -0,0 +1,79 @@
+/**
+ * Proxmox Backup Server retry surface — a veneer over
+ * `@distilled.cloud/core/retry`. Copied unchanged from
+ * `packages/proxmox/src/retry.ts` (no vendor-specific logic; only the
+ * Context.Service tag name below is package-local).
+ *
+ * The `Retry` service tag is threaded into every generated operation via
+ * `API.make({ retry: Retry })`, so a caller-installed policy applies to all
+ * Proxmox Backup Server calls below it and core's `makeDefault` is the
+ * fallback when none is provided.
+ *
+ * @example
+ * ```ts
+ * import * as ProxmoxBackup from "@distilled.cloud/proxmox-backup";
+ *
+ * myEffect.pipe(ProxmoxBackup.Retry.transient);
+ * ```
+ */
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Retries from "@distilled.cloud/core/retry";
+
+export type Options = Retries.Options;
+export type Factory = Retries.Factory;
+export type Policy = Retries.Policy;
+
+/** Context tag for configuring retry behavior of Proxmox Backup Server API calls. */
+export class Retry extends Context.Service<Retry, Policy>()(
+  "ProxmoxBackupRetry",
+) {}
+
+/** Provides a custom retry policy to every Proxmox Backup Server API call below it. */
+export const policy: {
+  (
+    options: Options,
+  ): <A, E, R>(
+    effect: Effect.Effect<A, E, R>,
+  ) => Effect.Effect<A, E, Exclude<R, Retry>>;
+  (
+    factory: Factory,
+  ): <A, E, R>(
+    effect: Effect.Effect<A, E, R>,
+  ) => Effect.Effect<A, E, Exclude<R, Retry>>;
+} = (optionsOrFactory: Options | Factory) =>
+  Effect.provide(Layer.succeed(Retry, optionsOrFactory));
+
+/** Disables all automatic retries. */
+export const none: <A, E, R>(
+  effect: Effect.Effect<A, E, R>,
+) => Effect.Effect<A, E, Exclude<R, Retry>> = Effect.provide(
+  Layer.succeed(Retry, { while: () => false }),
+);
+
+/**
+ * The default retry policy (core's): transient/throttling/retryable errors,
+ * capped exponential backoff with jitter, server `retryAfter` hints honored
+ * with precedence.
+ */
+export const makeDefault: Factory = Retries.makeDefault;
+
+export const jittered = Retries.jittered;
+export const capped = Retries.capped;
+
+/** Retry options that retry all throttling errors indefinitely. */
+export const throttlingOptions: Options = Retries.throttlingOptions;
+
+/** Retries all throttling errors indefinitely (honoring server hints). */
+export const throttling: <A, E, R>(
+  effect: Effect.Effect<A, E, R>,
+) => Effect.Effect<A, E, Exclude<R, Retry>> = policy(Retries.throttlingFactory);
+
+/** Retry options that retry all transient errors indefinitely. */
+export const transientOptions: Options = Retries.transientOptions;
+
+/** Retries all transient errors indefinitely (honoring server hints). */
+export const transient: <A, E, R>(
+  effect: Effect.Effect<A, E, R>,
+) => Effect.Effect<A, E, Exclude<R, Retry>> = policy(Retries.transientFactory);