import type {
AddOnPlansResponseEdgesItemNode,
AddOnsResponseEdgesItemNode,
CreateAddOnResponseAddOn,
} from "@distilled.cloud/fly-io/addons";
import * as addons from "@distilled.cloud/fly-io/addons";
import * as machines from "@distilled.cloud/fly-io/machines";
import { Unowned } from "alchemy/AdoptPolicy";
import { deepEqual, isResolved } from "alchemy/Diff";
import * as Provider from "alchemy/Provider";
import { Resource } from "alchemy/Resource";
import * as Data from "effect/Data";
import * as Duration from "effect/Duration";
import * as Effect from "effect/Effect";
import * as Redacted from "effect/Redacted";
import * as Result from "effect/Result";
import * as Schedule from "effect/Schedule";
import { resolveOrgSlug } from "./Environment.ts";
import { createFlyAppName, matchesAlchemyPhysicalName, sanitizeFlyAppName } from "./Metadata.ts";
import type { Providers } from "./Providers.ts";
export const DEFAULT_REDIS_REGION = "iad";
export const REDIS_ADDON_TYPE = "upstash_redis";
export const REDIS_PROVIDER = "upstash_redis";
export const REDIS_URL_ENV = "REDIS_URL";
// Re-export from the defining module, not the `@alchemy.run/redis` barrel:
// rolldown's lazyBarrel rejects an unused re-export from an `export *` barrel
// (https://github.com/rolldown/rolldown/issues/11344).
export {
CommandError as RedisCommandError,
UrlMissing as RedisUrlMissing,
} from "@alchemy.run/redis/Errors";
export interface RedisProps {
/**
* Upstash Redis database name. Globally unique in the org. If omitted,
* a unique name is generated from the stack, stage and logical ID.
* Changing it replaces the database.
*/
name?: string;
/**
* Primary region (`iad`, `ord`, `sjc`, …). Fly cannot move a primary.
* Changing it replaces the database.
*
* @default "iad"
*/
primaryRegion?: string;
/**
* Organization slug. Defaults to the current token's org. Changing it
* replaces the database.
*/
orgSlug?: string;
/**
* Add-on plan id, name, or display name from `addOnPlans`. Default is
* the cheapest listed plan (free or pay-as-you-go). Fixed plans are
* billed. Default tests use the cheapest listed plan.
*/
plan?: string;
/**
* Read-replica regions. Updated in place. Must not include the
* primary region.
*/
readRegions?: string[];
/**
* Evict keys when memory is full (cache workload). Updated in place.
*/
eviction?: boolean;
/**
* Automatically upgrade a fixed plan when hitting resource limits.
* Ignored on pay-as-you-go.
*/
autoUpgrade?: boolean;
/**
* ProdPack add-on ($200/mo). Paid. Not enabled in default tests.
*/
prodPack?: boolean;
}
export type Redis = Resource<
"Fly.Redis",
RedisProps,
{
/** Fly GraphQL add-on id. */
redisId: string;
/** Physical Upstash Redis name. */
name: string;
/** Primary region code. */
primaryRegion: string;
/** Observed read-replica regions. */
readRegions: string[];
/** Observed status (`ready`, `provisioning`, …). */
status: string | undefined;
/** Selected plan id, if the API returned one. */
planId: string | undefined;
/** Observed plan name (`Pay-as-you-go`, `Fixed 250MB`, …). */
planName: string | undefined;
/** Private 6PN address, if the API returned one. */
privateIp: string | undefined;
/** Organization slug. */
orgSlug: string | undefined;
/** Whether eviction is enabled. */
eviction: boolean | undefined;
/**
* Redacted Upstash connection URL. Bindings transport it to the
* runtime automatically. Service attachments also set `REDIS_URL`.
*/
url: Redacted.Redacted<string> | undefined;
},
never,
Providers
>;
/**
* Managed Upstash Redis in a Fly org. Bind {@link ReadRedis},
* {@link WriteRedis}, or {@link ReadWriteRedis} on a {@link Service}.
* Alchemy transports the redacted `url` Output to the runtime client
* and also writes `REDIS_URL` as an App secret for compatibility.
* Redis is not reachable from CI — drive it over HTTP.
*
* @see https://fly.io/docs/upstash/redis/
*
* ### Create Redis
* Alchemy generates a unique name unless you pass one. Default region is
* `iad`. Default plan is the cheapest `addOnPlans` row (free or
* pay-as-you-go).
*
* **Example:** Generated name
* ```typescript
* const cache = yield* Fly.Redis("Cache");
* ```
*
* :::note
* Prefer omitting `name` in tests and CI so names stay unique and
* reclaimable.
* :::
*
* ### A stable name
* Pass `name` when you want a stable Upstash database name.
*
* **Example:** Explicit name
* ```typescript
* const cache = yield* Fly.Redis("Cache", {
* name: "my-cache",
* primaryRegion: "iad",
* });
* ```
*
* :::caution[Changing `name` replaces Redis]
* Fly cannot rename an add-on. Alchemy deletes the old database first,
* then creates the new one.
* :::
*
* :::caution[Changing `primaryRegion` replaces Redis]
* The primary region is immutable. The old database is deleted first
* because the name cannot exist twice.
* :::
*
* ### Bind from a Service
* Yield {@link ReadWriteRedis} (or {@link ReadRedis} / {@link WriteRedis})
* in Service init. Provide the matching `*Http` layer.
*
* **Example:** Read and write
* ```typescript
* import * as HttpServerResponse from "effect/http/HttpServerResponse";
*
* const Cache = Fly.Redis("Cache");
*
* export default class Api extends Fly.Service<Api>()(
* "Api",
* { app: Site, main: import.meta.url, port: 3000 },
* Effect.gen(function* () {
* const cache = yield* Fly.ReadWriteRedis(Cache);
* return {
* fetch: Effect.gen(function* () {
* yield* cache.set("marker", "hello");
* const value = yield* cache.get("marker");
* return HttpServerResponse.json({ value });
* }),
* };
* }).pipe(Effect.provide(Fly.ReadWriteRedisHttp)),
* ) {}
* ```
*
* ### Eviction
* Enable eviction for cache workloads. Updated in place.
*
* **Example:** Eviction
* ```typescript
* const cache = yield* Fly.Redis("Cache", {
* eviction: true,
* });
* ```
*
* ### Read replicas
* `readRegions` are extra replica regions. Updated in place.
*
* **Example:** Replica region
* ```typescript
* const cache = yield* Fly.Redis("Cache", {
* primaryRegion: "iad",
* readRegions: ["sjc"],
* });
* ```
*
* ### Plan
* Omit `plan` for the cheapest listed plan. Pass a plan id or display
* name to pin one. Fixed plans are billed.
*
* **Example:** Pin pay-as-you-go
* ```typescript
* const cache = yield* Fly.Redis("Cache", {
* plan: "Pay-as-you-go",
* });
* ```
*
* :::caution[Fixed plans are billed]
* Fixed plans are billed monthly. Prefer omitting `plan` unless you
* need a specific size.
* :::
*
* @resource
* @product Redis
*/
export const Redis = Resource<Redis>("Fly.Redis");
export class RedisNotCreated extends Data.TaggedError("Fly.RedisNotCreated")<{
resourceName: string;
errorMessage?: string;
}> {}
export class RedisPlanNotFound extends Data.TaggedError("Fly.RedisPlanNotFound")<{
plan: string;
}> {}
export class RedisOrgMissing extends Data.TaggedError("Fly.RedisOrgMissing")<{
orgSlug: string;
}> {}
class RedisPending extends Data.TaggedError("Fly.RedisPending")<{
redisId: string;
status: string;
}> {}
type ObservedRedis = AddOnsResponseEdgesItemNode | CreateAddOnResponseAddOn;
type RedisPlan = AddOnPlansResponseEdgesItemNode;
const backoff = Schedule.min([
Schedule.exponential(Duration.millis(500), 1.5),
Schedule.spaced(Duration.seconds(5)),
]);
const unwrapSensitive = (
value: string | Redacted.Redacted<string> | null | undefined,
): string | undefined => {
if (value == null) return undefined;
return Redacted.isRedacted(value) ? Redacted.value(value) : value;
};
const recordOf = (value: unknown): Record<string, unknown> => {
if (value != null && typeof value === "object" && !Array.isArray(value)) {
return { ...(value as Record<string, unknown>) };
}
return {};
};
const stringRecordOf = (value: unknown): Record<string, string> =>
Object.fromEntries(
Object.entries(recordOf(value)).flatMap(([key, item]) =>
typeof item === "string" && item.length > 0 ? [[key, item]] : [],
),
);
const evictionOf = (options: unknown): boolean | undefined => {
const value = recordOf(options).eviction;
return typeof value === "boolean" ? value : undefined;
};
const sorted = (regions: readonly string[] | null | undefined): string[] =>
[...(regions ?? [])].sort();
const pendingStatus = (status: string | null | undefined): boolean => {
if (status == null || status.length === 0) return false;
const value = status.toLowerCase();
return (
value === "pending" || value === "provisioning" || value === "creating" || value === "launching"
);
};
const failedStatus = (status: string | null | undefined): boolean => {
if (status == null) return false;
const value = status.toLowerCase();
return value === "error" || value === "failed" || value === "destroyed";
};
const isLegacyPlanName = (plan: RedisPlan): boolean => {
const normalized = (plan.displayName ?? plan.name ?? "").toLowerCase().replaceAll(" ", "_");
return (
normalized === "pro_2k" ||
normalized === "pro_10k" ||
normalized === "starter" ||
normalized === "standard"
);
};
export const isFixedRedisPlan = (plan: Pick<RedisPlan, "name" | "displayName">): boolean => {
const display = (plan.displayName ?? "").toLowerCase();
const name = (plan.name ?? "").toLowerCase();
return display.startsWith("fixed ") || name.startsWith("flyio_fixed_");
};
const hasAlchemyMetadata = (metadata: unknown): boolean => {
const tags = stringRecordOf(metadata);
const stack = tags["alchemy::stack"] ?? tags["alchemy.stack"];
return stack !== undefined && stack.length > 0;
};
const isOwnedRedis = (row: ObservedRedis): boolean =>
matchesAlchemyPhysicalName(row.name ?? undefined) || hasAlchemyMetadata(row.metadata);
const resolveName = (id: string, name: string | undefined, existing?: string) =>
Effect.gen(function* () {
if (name !== undefined) return sanitizeFlyAppName(name);
if (existing !== undefined) return existing;
return yield* createFlyAppName(id);
});
const urlOf = (
row: ObservedRedis,
previous?: Redacted.Redacted<string>,
): Redacted.Redacted<string> | undefined => {
const raw = unwrapSensitive(row.publicUrl);
if (raw !== undefined && raw.length > 0) return Redacted.make(raw);
return previous;
};
const toAttrs = (
row: ObservedRedis,
fallback: {
name: string;
primaryRegion: string;
orgSlug?: string;
planId?: string;
url?: Redacted.Redacted<string>;
},
): Redis["Attributes"] => ({
redisId: row.id,
name: row.name ?? fallback.name,
primaryRegion: row.primaryRegion ?? fallback.primaryRegion,
readRegions: sorted(row.readRegions),
status: row.status ?? undefined,
planId:
"addOnPlan" in row
? ((row.addOnPlan as { id?: string } | null | undefined)?.id ?? fallback.planId)
: fallback.planId,
planName: row.addOnPlanName ?? undefined,
privateIp: row.privateIp ?? undefined,
orgSlug:
"organization" in row
? ((row.organization as { slug?: string | null } | undefined)?.slug ?? fallback.orgSlug)
: fallback.orgSlug,
eviction: evictionOf(row.options),
url: urlOf(row, fallback.url),
});
export const listRedisAddOns = Effect.fn(function* () {
const rows: AddOnsResponseEdgesItemNode[] = [];
let after: string | undefined;
for (let i = 0; i < 8; i++) {
const page = yield* addons.addOns({
type: REDIS_ADDON_TYPE,
first: 50,
after,
});
for (const edge of page.edges ?? []) {
if (edge?.node != null) rows.push(edge.node);
}
if (!page.pageInfo.hasNextPage) break;
after = page.pageInfo.endCursor ?? undefined;
if (after === undefined || after.length === 0) break;
}
return rows;
});
export const listRedisPlans = Effect.fn(function* () {
const rows: RedisPlan[] = [];
let after: string | undefined;
for (let i = 0; i < 4; i++) {
const page = yield* addons.addOnPlans({
type: REDIS_ADDON_TYPE,
first: 50,
after,
});
for (const edge of page.edges ?? []) {
if (edge?.node != null) rows.push(edge.node);
}
if (!page.pageInfo.hasNextPage) break;
after = page.pageInfo.endCursor ?? undefined;
if (after === undefined || after.length === 0) break;
}
return rows;
});
export const findRedisAddOn = (input: { id?: string; name?: string }) =>
listRedisAddOns().pipe(
Effect.map((rows) =>
rows.find((row) => {
if (input.id !== undefined && row.id === input.id) return true;
if (input.name !== undefined && row.name === input.name) return true;
return false;
}),
),
);
const cheapestPlan = (plans: RedisPlan[]) => {
const usable = plans.filter((plan) => !isLegacyPlanName(plan));
const pool = usable.length > 0 ? usable : plans;
if (pool.length === 0) return undefined;
const free = pool.filter((plan) => (plan.pricePerMonth ?? 0) === 0);
const ranked = (free.length > 0 ? free : pool).slice().sort((left, right) => {
const byPrice = (left.pricePerMonth ?? 0) - (right.pricePerMonth ?? 0);
if (byPrice !== 0) return byPrice;
return (left.displayName ?? left.name ?? "").localeCompare(
right.displayName ?? right.name ?? "",
);
});
const payg = ranked.find((plan) =>
/pay.?as.?you.?go|free/i.test(`${plan.displayName ?? ""} ${plan.name ?? ""}`),
);
return payg ?? ranked[0];
};
const resolvePlan = (plan: string | undefined, existingId: string | undefined) =>
Effect.gen(function* () {
const plans = yield* listRedisPlans();
if (plan !== undefined) {
const found = plans.find(
(item) => item.id === plan || item.name === plan || item.displayName === plan,
);
if (found === undefined) {
return yield* new RedisPlanNotFound({ plan });
}
return found;
}
if (existingId !== undefined) {
const existing = plans.find((item) => item.id === existingId);
if (existing !== undefined) return existing;
}
const cheapest = cheapestPlan(plans);
if (cheapest === undefined) {
return yield* new RedisPlanNotFound({ plan: "default" });
}
return cheapest;
});
const resolveOrganization = (orgSlug: string) =>
addons
.organization({ slug: orgSlug })
.pipe(Effect.catchTag("FlyIoParseError", () => Effect.undefined));
const ensureTos = (orgSlug: string, organizationId: string) =>
Effect.gen(function* () {
const agreed = yield* addons.agreedToProviderTos({
slug: orgSlug,
providerName: REDIS_PROVIDER,
});
if (agreed === true) return;
// Tokens without org-admin cannot write the ToS row. Create still
// succeeds when the org already agreed via flyctl.
yield* Effect.result(
addons.createExtensionTosAgreement({
input: {
addOnProviderName: REDIS_PROVIDER,
organizationId,
},
}),
);
});
const waitUntilReady = (id: string, name: string) =>
findRedisAddOn({ id, name }).pipe(
Effect.flatMap(
(row): Effect.Effect<AddOnsResponseEdgesItemNode, RedisPending | RedisNotCreated> => {
if (row === undefined) {
return Effect.fail(new RedisPending({ redisId: id, status: "missing" }));
}
if (failedStatus(row.status)) {
return Effect.fail(
new RedisNotCreated({
resourceName: row.name ?? name,
errorMessage: row.errorMessage ?? row.status ?? undefined,
}),
);
}
if (pendingStatus(row.status)) {
return Effect.fail(
new RedisPending({
redisId: id,
status: row.status ?? "provisioning",
}),
);
}
return Effect.succeed(row);
},
),
Effect.retry({
while: (error) => error._tag === "Fly.RedisPending",
times: 10,
schedule: backoff,
}),
Effect.catchTag("Fly.RedisPending", () => findRedisAddOn({ id, name })),
);
const waitUntilGone = (id: string, name: string) =>
findRedisAddOn({ id, name }).pipe(
Effect.map((row) => row === undefined),
Effect.repeat({
schedule: Schedule.spaced("2 seconds"),
until: (gone) => gone,
times: 10,
}),
);
const desiredOptions = (
props: RedisProps,
plan: RedisPlan,
observed: unknown,
): Record<string, unknown> => {
const options = recordOf(observed);
if (props.eviction !== undefined) options.eviction = props.eviction;
if (isFixedRedisPlan(plan)) {
if (props.autoUpgrade !== undefined) {
options.auto_upgrade = props.autoUpgrade;
}
} else {
delete options.auto_upgrade;
}
delete options.prod_pack;
return options;
};
class RedisSecretVersionMissing extends Data.TaggedError("Fly.RedisSecretVersionMissing")<{
appName: string;
}> {}
const redisSecretVersion = (
appName: string,
response: machines.AppSecretsUpdateResp | machines.SetAppSecretResponse,
) => {
const version = response.version ?? response.Version;
return version !== undefined && Number.isSafeInteger(version) && version >= 0
? Effect.succeed(version)
: Effect.fail(new RedisSecretVersionMissing({ appName }));
};
/**
* Write `REDIS_URL` onto an App from attached Redis add-on names.
* Called from {@link Service} reconcile so the secret exists before
* Machines boot. Returns the highest accepted secret-version floor, or
* `undefined` when no secret was written; this is not a vault snapshot.
*/
export const attachRedisSecrets = Effect.fn(function* (
appName: string,
attached: readonly { name: string; id?: string }[],
) {
if (appName.length === 0 || attached.length === 0) return undefined;
const versions: number[] = [];
for (const item of attached) {
const name = item.name;
const id = item.id;
if (name.length === 0 && (id === undefined || id.length === 0)) continue;
const row = yield* findRedisAddOn({ id, name }).pipe(
Effect.flatMap((found) =>
found === undefined
? Effect.fail(
new RedisPending({
redisId: id ?? "",
status: "missing",
}),
)
: Effect.succeed(found),
),
Effect.retry({
while: (error) => error._tag === "Fly.RedisPending",
times: 8,
schedule: backoff,
}),
Effect.catchTag("Fly.RedisPending", () => findRedisAddOn({ id, name })),
);
if (row === undefined) {
return yield* new RedisPending({
redisId: id ?? name,
status: "missing",
});
}
let url = unwrapSensitive(row.publicUrl);
if ((url === undefined || url.length === 0) && row.id !== undefined) {
const detail = yield* addons
.addOn({ id: row.id })
.pipe(Effect.catchTag("FlyIoParseError", () => Effect.undefined));
url = unwrapSensitive(detail?.publicUrl);
}
if (url === undefined || url.length === 0) {
return yield* new RedisPending({
redisId: row.id ?? id ?? name,
status: "credentials missing",
});
}
const value = url;
const update = machines
.updateSecrets({
app_name: appName,
values: { [REDIS_URL_ENV]: value },
})
.pipe(Effect.flatMap((response) => redisSecretVersion(appName, response)));
const version = yield* update.pipe(
Effect.catchTag("NotFound", () =>
machines
.createSecret({
app_name: appName,
secret_name: REDIS_URL_ENV,
value,
})
.pipe(
Effect.flatMap((response) => redisSecretVersion(appName, response)),
Effect.catchTag("Conflict", () => update),
),
),
);
versions.push(version);
}
return versions.length > 0 ? Math.max(...versions) : undefined;
});
export const RedisProvider = () =>
Provider.succeed(Redis, {
stables: ["redisId", "name", "primaryRegion", "orgSlug"],
diff: Effect.fn(function* ({ news, output }) {
if (news === undefined || !isResolved(news)) return undefined;
if (output === undefined) return undefined;
const desiredName = news.name !== undefined ? sanitizeFlyAppName(news.name) : output.name;
const nameChanged = desiredName !== output.name;
const desiredRegion = news.primaryRegion ?? DEFAULT_REDIS_REGION;
const regionChanged = desiredRegion !== output.primaryRegion;
const orgChanged = news.orgSlug !== undefined && news.orgSlug !== output.orgSlug;
if (nameChanged || regionChanged || orgChanged) {
return {
action: "replace" as const,
deleteFirst: !nameChanged,
};
}
return undefined;
}),
read: Effect.fn(function* ({ id, olds, output }) {
const name = yield* resolveName(id, olds?.name, output?.name);
const found =
(output?.redisId !== undefined
? yield* findRedisAddOn({ id: output.redisId, name: output.name })
: undefined) ?? (yield* findRedisAddOn({ name }));
if (found === undefined) return undefined;
const attrs = toAttrs(found, {
name,
primaryRegion: olds?.primaryRegion ?? DEFAULT_REDIS_REGION,
orgSlug: olds?.orgSlug ?? output?.orgSlug,
url: output?.url,
});
if (output !== undefined) return attrs;
return isOwnedRedis(found) ? attrs : Unowned(attrs);
}),
list: Effect.fn(function* () {
const rows = yield* listRedisAddOns();
return rows.flatMap((row) => {
if (!isOwnedRedis(row)) return [];
const name = row.name;
if (name == null || name.length === 0) return [];
return [
toAttrs(row, {
name,
primaryRegion: row.primaryRegion ?? DEFAULT_REDIS_REGION,
}),
];
});
}),
reconcile: Effect.fn(function* ({ id, news, output }) {
const props = news ?? {};
const name = yield* resolveName(id, props.name, output?.name);
const primaryRegion = props.primaryRegion ?? output?.primaryRegion ?? DEFAULT_REDIS_REGION;
const orgSlug = props.orgSlug ?? (yield* resolveOrgSlug());
const org = yield* resolveOrganization(orgSlug);
if (org === undefined) {
return yield* new RedisOrgMissing({ orgSlug });
}
let current: ObservedRedis | undefined =
output?.redisId !== undefined
? yield* findRedisAddOn({
id: output.redisId,
name: output.name,
})
: undefined;
if (current === undefined && (output === undefined || output.name !== name)) {
current = yield* findRedisAddOn({ name });
}
const plan = yield* resolvePlan(
props.plan,
current !== undefined && "addOnPlan" in current ? current.addOnPlan?.id : output?.planId,
);
if (current === undefined) {
yield* ensureTos(orgSlug, org.id);
const created = yield* Effect.result(
addons.createAddOn({
input: {
type: REDIS_ADDON_TYPE,
name,
organizationId: org.id,
planId: plan.id,
primaryRegion,
readRegions: props.readRegions ?? [],
options: desiredOptions(props, plan, undefined),
},
}),
);
if (Result.isSuccess(created)) {
current = created.success.addOn;
} else {
current = yield* findRedisAddOn({ name });
if (current === undefined) {
return yield* created.failure;
}
}
}
if (current === undefined) {
return yield* new RedisNotCreated({ resourceName: name });
}
if (pendingStatus(current.status)) {
const ready = yield* waitUntilReady(current.id, name);
if (ready !== undefined) current = ready;
}
if (current === undefined) {
return yield* new RedisNotCreated({ resourceName: name });
}
const observedOptions = recordOf(current.options);
const nextOptions = desiredOptions(props, plan, current.options);
const nextReadRegions = sorted(props.readRegions ?? current.readRegions ?? []);
const observedReadRegions = sorted(current.readRegions);
const observedPlanId = "addOnPlan" in current ? current.addOnPlan?.id : output?.planId;
const planChanged = observedPlanId !== undefined && observedPlanId !== plan.id;
const regionsChanged = !deepEqual(observedReadRegions, nextReadRegions);
const optionsChanged = !deepEqual(observedOptions, nextOptions);
const prodPackChanged = props.prodPack !== undefined && planChanged;
if (planChanged || regionsChanged || optionsChanged || prodPackChanged) {
const updated = yield* Effect.result(
addons.updateAddOn({
input: {
addOnId: current.id,
planId: plan.id,
readRegions: nextReadRegions,
options: nextOptions,
prodPack: prodPackChanged ? props.prodPack : undefined,
},
}),
);
if (Result.isSuccess(updated)) {
current = {
...current,
...updated.success.addOn,
};
} else {
const refreshed = yield* findRedisAddOn({
id: current.id,
name,
});
if (refreshed !== undefined) current = refreshed;
}
}
let latest = (yield* findRedisAddOn({ id: current.id, name })) ?? current;
if (unwrapSensitive(latest.publicUrl) === undefined && latest.id !== undefined) {
const detail = yield* addons.addOn({ id: latest.id });
latest = { ...latest, ...detail };
}
return toAttrs(latest, {
name,
primaryRegion,
orgSlug,
planId: plan.id,
url: output?.url,
});
}),
delete: Effect.fn(function* ({ output }) {
const redisId = output.redisId;
const name = output.name;
if (redisId.length === 0 && (name === undefined || name.length === 0)) {
return;
}
const deleted = yield* Effect.result(
addons.deleteAddOn({
input: redisId.length > 0 ? { addOnId: redisId } : { name, provider: REDIS_PROVIDER },
}),
);
if (Result.isFailure(deleted)) {
const still = yield* findRedisAddOn({ id: redisId, name });
if (still !== undefined) {
return yield* deleted.failure;
}
return;
}
yield* waitUntilGone(redisId, name);
}),
});