import * as workers from "@distilled.cloud/cloudflare/workers";
import * as Provider from "alchemy/Provider";
import { Resource } from "alchemy/Resource";
import * as Effect from "effect/Effect";
import * as Predicate from "effect/Predicate";
import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
import type { Providers } from "../Providers.ts";
const TypeId = "Cloudflare.Workers.AccountSetting" as const;
type TypeId = typeof TypeId;
export type AccountSettingProps = {
/**
* Default usage model applied to new Workers in this account (e.g.
* `"standard"`). Mostly legacy since Workers Standard pricing — new
* accounts only support `"standard"`.
*
* Mutable — updated in place. When omitted, the account's current value
* is left untouched.
* @default keep the account's current value
*/
defaultUsageModel?: string;
/**
* Whether Green Compute is enabled for the account. When enabled,
* scheduled (cron) Workers run only on hardware powered by renewable
* energy.
*
* Mutable — updated in place. When omitted, the account's current value
* is left untouched.
* @default keep the account's current value
*/
greenCompute?: boolean;
};
export type AccountSettingAttributes = {
/** The Cloudflare account these settings belong to. */
accountId: string;
/** Resolved default usage model for the account. */
defaultUsageModel: string | undefined;
/** Resolved Green Compute flag for the account. */
greenCompute: boolean | undefined;
/**
* The `defaultUsageModel` the account had before Alchemy first managed
* this singleton. Restored on destroy.
*/
initialDefaultUsageModel: string | undefined;
/**
* The `greenCompute` flag the account had before Alchemy first managed
* this singleton. Restored on destroy.
*/
initialGreenCompute: boolean | undefined;
};
export type AccountSetting = Resource<
TypeId,
AccountSettingProps,
AccountSettingAttributes,
never,
Providers
>;
/**
* The account-wide Workers settings singleton
* (`/accounts/{account_id}/workers/account-settings`): the default usage
* model for new Workers and the Green Compute flag for scheduled Workers.
*
* This is a singleton — it always exists on every account with Cloudflare
* defaults, so this resource never creates or deletes anything physical.
* Reconcile PUTs the settings when the observed values differ from the
* desired ones; destroy restores the values the account had before Alchemy
* first managed it (captured as `initialDefaultUsageModel` /
* `initialGreenCompute`).
* ### Managing account settings
* **Example:** Enable Green Compute for scheduled Workers
* ```typescript
* yield* Cloudflare.Workers.AccountSetting("GreenCompute", {
* greenCompute: true,
* });
* ```
*
* **Example:** Pin the default usage model
* ```typescript
* yield* Cloudflare.Workers.AccountSetting("UsageModel", {
* defaultUsageModel: "standard",
* greenCompute: false,
* });
* ```
*
* @see https://developers.cloudflare.com/api/resources/workers/subresources/account_settings/
*
* @resource
* @product Workers
* @category Workers & Compute
*/
export const AccountSetting = Resource<AccountSetting>(TypeId);
/**
* Returns true if the given value is a AccountSetting resource.
*/
export const isAccountSetting = (value: unknown): value is AccountSetting =>
Predicate.hasProperty(value, "Type") && value.Type === TypeId;
export const AccountSettingProvider = () =>
Provider.succeed(AccountSetting, {
nuke: { singleton: true },
stables: ["accountId", "initialDefaultUsageModel", "initialGreenCompute"],
diff: Effect.fn(function* ({ output }) {
const { accountId } = yield* yield* CloudflareEnvironment;
// The singleton's identity is the account it lives on.
if (output !== undefined && output.accountId !== accountId) {
return { action: "replace" } as const;
}
return undefined;
}),
read: Effect.fn(function* ({ output }) {
const { accountId } = yield* yield* CloudflareEnvironment;
const acct = output?.accountId ?? accountId;
const observed = yield* workers.getAccountSetting({ accountId: acct });
// The settings singleton always exists with Cloudflare defaults —
// there is nothing to "own", so a cold read adopts freely (never
// `Unowned`). The observed values at adoption time become the
// initial values restored on destroy.
return toAttributes(
acct,
observed,
output !== undefined
? output.initialDefaultUsageModel
: (observed.defaultUsageModel ?? undefined),
output !== undefined ? output.initialGreenCompute : (observed.greenCompute ?? undefined),
);
}),
// Account-scoped singleton: there is no collection API — the settings
// object always exists once per account. Read the single live object and
// return it as a one-element array, exactly mirroring `read` (a cold
// observation where the observed values are the initial values).
list: Effect.fn(function* () {
const { accountId } = yield* yield* CloudflareEnvironment;
const observed = yield* workers.getAccountSetting({ accountId });
return [
toAttributes(
accountId,
observed,
observed.defaultUsageModel ?? undefined,
observed.greenCompute ?? undefined,
),
];
}),
reconcile: Effect.fn(function* ({ news, output }) {
const { accountId } = yield* yield* CloudflareEnvironment;
// 1. Observe — the singleton always exists; read its live values.
const observed = yield* workers.getAccountSetting({ accountId });
// 2. Capture — the pre-management values, restored on destroy.
// `output` (including an adoption read) already carries them;
// otherwise this is our first touch and the observed values are
// the account's originals.
const initialDefaultUsageModel =
output !== undefined
? output.initialDefaultUsageModel
: (observed.defaultUsageModel ?? undefined);
const initialGreenCompute =
output !== undefined ? output.initialGreenCompute : (observed.greenCompute ?? undefined);
// 3. Sync — desired = news merged over observed (unspecified props
// keep the account's current value); PUT only when dirty.
const desired = {
defaultUsageModel: news.defaultUsageModel ?? observed.defaultUsageModel ?? undefined,
greenCompute: news.greenCompute ?? observed.greenCompute ?? undefined,
};
const dirty =
(news.defaultUsageModel !== undefined &&
(observed.defaultUsageModel ?? undefined) !== news.defaultUsageModel) ||
(news.greenCompute !== undefined &&
(observed.greenCompute ?? undefined) !== news.greenCompute);
if (!dirty) {
return toAttributes(accountId, observed, initialDefaultUsageModel, initialGreenCompute);
}
yield* workers.putAccountSetting({ accountId, ...desired });
// 4. Return — the PUT is authoritative for what we just wrote. We do
// NOT re-read here: `getAccountSetting` is eventually consistent and
// can briefly echo the pre-write values right after a PUT (observed
// under concurrent load), which would surface a stale `greenCompute`
// in the reconcile output. The values we sent are the new state.
return {
accountId,
defaultUsageModel: desired.defaultUsageModel,
greenCompute: desired.greenCompute,
initialDefaultUsageModel,
initialGreenCompute,
};
}),
delete: Effect.fn(function* ({ output }) {
const { accountId, initialDefaultUsageModel, initialGreenCompute } = output;
// There is no DELETE API — destroy restores the pre-management
// values. Skip the call when the live values already match
// (idempotent re-delete after a crashed run).
const observed = yield* workers.getAccountSetting({ accountId });
const dirty =
(initialDefaultUsageModel !== undefined &&
(observed.defaultUsageModel ?? undefined) !== initialDefaultUsageModel) ||
(initialGreenCompute !== undefined &&
(observed.greenCompute ?? undefined) !== initialGreenCompute);
if (!dirty) return;
yield* workers.putAccountSetting({
accountId,
defaultUsageModel: initialDefaultUsageModel ?? observed.defaultUsageModel ?? undefined,
greenCompute: initialGreenCompute ?? observed.greenCompute ?? undefined,
});
}),
});
const toAttributes = (
accountId: string,
observed: workers.GetAccountSettingResponse,
initialDefaultUsageModel: string | undefined,
initialGreenCompute: boolean | undefined,
): AccountSettingAttributes => ({
accountId,
defaultUsageModel: observed.defaultUsageModel ?? undefined,
greenCompute: observed.greenCompute ?? undefined,
initialDefaultUsageModel,
initialGreenCompute,
});