import { withRequestOptions } from "@distilled.cloud/stripe";
import {
DeleteTerminalConfiguration,
GetTerminalConfigurations,
GetTerminalConfiguration,
CreateTerminalConfiguration,
UpdateTerminalConfiguration,
type DeletedTerminalConfiguration,
type CreateTerminalConfigurationRequest,
type CreateTerminalConfigurationRequestTippingCase0,
type CreateTerminalConfigurationRequestWifiCase0,
type TerminalConfiguration as StripeTerminalConfiguration,
type TerminalConfigurationConfigurationResourceCurrencySpecificConfig,
type TerminalConfigurationConfigurationResourceDeviceTypeSpecificConfig,
type TerminalConfigurationConfigurationResourceTipping,
type TerminalConfigurationConfigurationResourceWifiConfig,
} from "@distilled.cloud/stripe/stripe";
import { Unowned } from "alchemy/AdoptPolicy";
import { deepEqual, isResolved } from "alchemy/Diff";
import { createPhysicalName } from "alchemy/PhysicalName";
import * as Provider from "alchemy/Provider";
import { Resource } from "alchemy/Resource";
import * as Data from "effect/Data";
import * as Effect from "effect/Effect";
import { isMissingStripeResource } from "./missing.ts";
import type { Providers } from "./Providers.ts";
const NAME_MAX_LENGTH = 250;
const LIST_PAGE_SIZE = 100;
const LIST_MAX_PAGES = 100;
/** Fixed amounts / percentages shown when collecting an on-reader tip. */
export interface TerminalTippingCurrency {
/**
* Fixed amounts (in the currency's minor units) displayed when
* collecting a tip.
*/
fixedAmounts?: number[];
/**
* Percentages displayed when collecting a tip.
*/
percentages?: number[];
/**
* Below this amount (minor units), fixed amounts are shown; above it,
* percentages are shown. Requires both `fixedAmounts` and `percentages`.
*/
smartTipThreshold?: number;
}
/** Per-currency on-reader tipping. Keys are lowercase ISO 4217 codes. */
export interface TerminalTipping {
/** Tipping configuration for AED. */
aed?: TerminalTippingCurrency;
/** Tipping configuration for AUD. */
aud?: TerminalTippingCurrency;
/** Tipping configuration for CAD. */
cad?: TerminalTippingCurrency;
/** Tipping configuration for CHF. */
chf?: TerminalTippingCurrency;
/** Tipping configuration for CZK. */
czk?: TerminalTippingCurrency;
/** Tipping configuration for DKK. */
dkk?: TerminalTippingCurrency;
/** Tipping configuration for EUR. */
eur?: TerminalTippingCurrency;
/** Tipping configuration for GBP. */
gbp?: TerminalTippingCurrency;
/** Tipping configuration for GIP. */
gip?: TerminalTippingCurrency;
/** Tipping configuration for HKD. */
hkd?: TerminalTippingCurrency;
/** Tipping configuration for HUF. */
huf?: TerminalTippingCurrency;
/** Tipping configuration for JPY. */
jpy?: TerminalTippingCurrency;
/** Tipping configuration for MXN. */
mxn?: TerminalTippingCurrency;
/** Tipping configuration for MYR. */
myr?: TerminalTippingCurrency;
/** Tipping configuration for NOK. */
nok?: TerminalTippingCurrency;
/** Tipping configuration for NZD. */
nzd?: TerminalTippingCurrency;
/** Tipping configuration for PLN. */
pln?: TerminalTippingCurrency;
/** Tipping configuration for RON. */
ron?: TerminalTippingCurrency;
/** Tipping configuration for SEK. */
sek?: TerminalTippingCurrency;
/** Tipping configuration for SGD. */
sgd?: TerminalTippingCurrency;
/** Tipping configuration for USD. */
usd?: TerminalTippingCurrency;
}
/** Device-specific splash screen. */
export interface TerminalDeviceConfig {
/**
* Stripe File id of an image to display on the reader. Empty string
* clears it on update.
*/
splashscreen?: string;
}
/** Offline-mode collection. */
export interface TerminalOffline {
/**
* Whether the reader may collect transactions while offline.
*/
enabled: boolean;
}
/** Cellular connectivity. */
export interface TerminalCellular {
/**
* Whether a cellular-capable reader may connect over cellular.
*/
enabled: boolean;
}
/** Daily reboot window (hours in 0–23). */
export interface TerminalRebootWindow {
/**
* Start hour of the reboot window (0–23).
*/
startHour: number;
/**
* End hour of the reboot window (0–23). Must differ from `startHour`.
*/
endHour: number;
}
/** Wi-Fi security type. */
export type TerminalWifiType = "enterprise_eap_peap" | "enterprise_eap_tls" | "personal_psk";
/** WPA-Enterprise EAP-PEAP credentials. */
export interface TerminalWifiEnterprisePeap {
/**
* Wi-Fi network name.
*/
ssid: string;
/**
* Username for the network.
*/
username: string;
/**
* Password for the network. Never returned on read.
*/
password: string;
/**
* Stripe File id of a PEM containing the server certificate.
*/
caCertificateFile?: string;
}
/** WPA-Enterprise EAP-TLS credentials. */
export interface TerminalWifiEnterpriseTls {
/**
* Wi-Fi network name.
*/
ssid: string;
/**
* Stripe File id of a PEM containing the client certificate.
*/
clientCertificateFile: string;
/**
* Stripe File id of a PEM containing the client RSA private key.
*/
privateKeyFile: string;
/**
* Stripe File id of a PEM containing the server certificate.
*/
caCertificateFile?: string;
/**
* Password for the private key file. Never returned on read.
*/
privateKeyFilePassword?: string;
}
/** WPA-Personal PSK credentials. */
export interface TerminalWifiPersonalPsk {
/**
* Wi-Fi network name.
*/
ssid: string;
/**
* Password for the network. Never returned on read.
*/
password: string;
}
/** Reader Wi-Fi configuration. */
export interface TerminalWifi {
/**
* Security type. The matching nested object holds the credentials.
*/
type: TerminalWifiType;
/**
* EAP-PEAP credentials. Required when `type` is `enterprise_eap_peap`.
*/
enterpriseEapPeap?: TerminalWifiEnterprisePeap;
/**
* EAP-TLS credentials. Required when `type` is `enterprise_eap_tls`.
*/
enterpriseEapTls?: TerminalWifiEnterpriseTls;
/**
* Personal PSK credentials. Required when `type` is `personal_psk`.
*/
personalPsk?: TerminalWifiPersonalPsk;
}
/** Observed Wi-Fi state with secrets stripped. */
export interface TerminalWifiState {
/**
* Security type currently configured.
*/
type: TerminalWifiType;
/**
* Observed EAP-PEAP settings (password omitted).
*/
enterpriseEapPeap?: {
ssid: string;
username: string;
caCertificateFile: string | undefined;
};
/**
* Observed EAP-TLS settings (private-key password omitted).
*/
enterpriseEapTls?: {
ssid: string;
clientCertificateFile: string;
privateKeyFile: string;
caCertificateFile: string | undefined;
};
/**
* Observed personal PSK settings (password omitted).
*/
personalPsk?: {
ssid: string;
};
}
export interface TerminalConfigurationProps {
/**
* Display name of the configuration. If omitted, a unique name is
* generated from the stack, stage, and logical id. Mutable. Used as the
* lookup key when the Stripe id is missing — this object has no
* metadata.
*/
name?: string;
/**
* Offline transaction collection. `null` clears it on update.
*/
offline?: TerminalOffline | null;
/**
* On-reader tipping by currency. `null` clears it on update.
*/
tipping?: TerminalTipping | null;
/**
* Daily reboot window. `null` clears it on update.
*/
rebootWindow?: TerminalRebootWindow | null;
/**
* Cellular connectivity. `null` clears it on update.
*/
cellular?: TerminalCellular | null;
/**
* Reader Wi-Fi. `null` clears it on update. Passwords are write-only.
*/
wifi?: TerminalWifi | null;
/**
* BBPOS WisePad 3 splash screen. `null` clears it on update.
*/
bbposWisepad3?: TerminalDeviceConfig | null;
/**
* BBPOS WisePOS E splash screen. `null` clears it on update.
*/
bbposWiseposE?: TerminalDeviceConfig | null;
/**
* Stripe S700 splash screen. `null` clears it on update.
*/
stripeS700?: TerminalDeviceConfig | null;
/**
* Stripe S710 splash screen. `null` clears it on update.
*/
stripeS710?: TerminalDeviceConfig | null;
/**
* Verifone M425 splash screen. `null` clears it on update.
*/
verifoneM425?: TerminalDeviceConfig | null;
/**
* Verifone P400 splash screen. `null` clears it on update.
*/
verifoneP400?: TerminalDeviceConfig | null;
/**
* Verifone P630 splash screen. `null` clears it on update.
*/
verifoneP630?: TerminalDeviceConfig | null;
/**
* Verifone UX700 splash screen. `null` clears it on update.
*/
verifoneUx700?: TerminalDeviceConfig | null;
/**
* Verifone V660p splash screen. `null` clears it on update.
*/
verifoneV660p?: TerminalDeviceConfig | null;
}
type DeviceKey = (typeof DEVICE_MAP)[number][0];
type SnakeDeviceKey = (typeof DEVICE_MAP)[number][1];
const DEVICE_MAP = [
["bbposWisepad3", "bbpos_wisepad3"],
["bbposWiseposE", "bbpos_wisepos_e"],
["stripeS700", "stripe_s700"],
["stripeS710", "stripe_s710"],
["verifoneM425", "verifone_m425"],
["verifoneP400", "verifone_p400"],
["verifoneP630", "verifone_p630"],
["verifoneUx700", "verifone_ux700"],
["verifoneV660p", "verifone_v660p"],
] as const satisfies ReadonlyArray<readonly [string, string]>;
const TIPPING_CURRENCIES = [
"aed",
"aud",
"cad",
"chf",
"czk",
"dkk",
"eur",
"gbp",
"gip",
"hkd",
"huf",
"jpy",
"mxn",
"myr",
"nok",
"nzd",
"pln",
"ron",
"sek",
"sgd",
"usd",
] as const satisfies ReadonlyArray<keyof TerminalTipping>;
type DeviceAttributes = {
[K in DeviceKey]: TerminalDeviceConfig | undefined;
};
export type TerminalConfiguration = Resource<
"Stripe.TerminalConfiguration",
TerminalConfigurationProps,
{
/** Stripe Terminal configuration id (`tmc_…`). */
id: string;
/** Display name of the configuration, if set. */
name: string | undefined;
/** Whether this is the account's default configuration. */
isAccountDefault: boolean;
/** Offline transaction collection, if configured. */
offline: TerminalOffline | undefined;
/** On-reader tipping by currency, if configured. */
tipping: TerminalTipping | undefined;
/** Daily reboot window, if configured. */
rebootWindow: TerminalRebootWindow | undefined;
/** Cellular connectivity, if configured. */
cellular: TerminalCellular | undefined;
/** Observed Wi-Fi (passwords omitted). */
wifi: TerminalWifiState | undefined;
/** Whether the configuration exists in live mode. */
livemode: boolean;
} & DeviceAttributes,
never,
Providers
>;
/**
* A Stripe Terminal Configuration — splash screens, tipping, offline
* mode, reboot window, cellular, and Wi-Fi for smart readers. Name and
* nested settings update in place. Destroy hard-deletes the
* configuration. The account default configuration is never adopted or
* listed.
*
* Terminal configurations have no metadata field. Identity is the Stripe
* id plus the unique name. Account-wide `list()` (nuke) enumerates every
* non-default configuration on the account.
*
* @see https://docs.stripe.com/api/terminal/configuration
*
* ### Creating a Configuration
* **Example:** Named configuration with USD tipping
* ```typescript
* const config = yield* Stripe.TerminalConfiguration("storefront", {
* name: "Storefront",
* offline: { enabled: true },
* tipping: {
* usd: {
* fixedAmounts: [100, 200, 300],
* percentages: [15, 20, 25],
* smartTipThreshold: 1000,
* },
* },
* });
* ```
*
* **Example:** Reboot window
* ```typescript
* const config = yield* Stripe.TerminalConfiguration("storefront", {
* name: "Storefront",
* rebootWindow: { startHour: 2, endHour: 4 },
* });
* ```
*
* ### Updating a Configuration
* **Example:** Rename and change tipping
* ```typescript
* const config = yield* Stripe.TerminalConfiguration("storefront", {
* name: "Storefront (updated)",
* offline: { enabled: false },
* tipping: {
* usd: {
* fixedAmounts: [200, 300, 400],
* percentages: [10, 15, 20],
* smartTipThreshold: 2000,
* },
* },
* });
* ```
*
* ### Deleting a Configuration
* **Example:** Destroy deletes the configuration
* ```typescript
* // stack.destroy() / resource removal hard-deletes the configuration
* const config = yield* Stripe.TerminalConfiguration("storefront", {
* name: "Storefront",
* });
* ```
*
* @resource
* @product Terminal
*/
export const TerminalConfiguration = Resource<TerminalConfiguration>(
"Stripe.TerminalConfiguration",
);
export class TerminalConfigurationNotResolved extends Data.TaggedError(
"Stripe.TerminalConfigurationNotResolved",
)<{
configurationId: string | undefined;
resourceName: string;
}> {}
type ConfigurationAttributes = TerminalConfiguration["Attributes"];
const toName = (id: string, name: string | undefined, existing?: string) =>
Effect.gen(function* () {
return name ?? existing ?? (yield* createPhysicalName({ id, maxLength: NAME_MAX_LENGTH }));
});
const isDeletedConfiguration = (
value: StripeTerminalConfiguration | DeletedTerminalConfiguration,
): value is DeletedTerminalConfiguration => "deleted" in value && value.deleted === true;
const asConfiguration = (
value: StripeTerminalConfiguration | DeletedTerminalConfiguration | undefined,
): StripeTerminalConfiguration | undefined => {
if (value === undefined || isDeletedConfiguration(value)) return undefined;
return value;
};
const isAccountDefault = (configuration: StripeTerminalConfiguration) =>
configuration.is_account_default === true;
const toFileId = (value: unknown): string | undefined => {
if (value === undefined || value === null) return undefined;
if (typeof value === "string") return value === "" ? undefined : value;
if (
typeof value === "object" &&
"id" in value &&
typeof (value as { id: unknown }).id === "string"
) {
return (value as { id: string }).id;
}
return undefined;
};
const toDeviceState = (
value: TerminalConfigurationConfigurationResourceDeviceTypeSpecificConfig | undefined,
): TerminalDeviceConfig | undefined => {
if (value === undefined) return undefined;
const splashscreen = toFileId(value.splashscreen);
return splashscreen === undefined ? {} : { splashscreen };
};
const toTippingCurrency = (
value: TerminalConfigurationConfigurationResourceCurrencySpecificConfig | undefined,
): TerminalTippingCurrency | undefined => {
if (value === undefined) return undefined;
return {
...(value.fixed_amounts != null ? { fixedAmounts: value.fixed_amounts } : {}),
...(value.percentages != null ? { percentages: value.percentages } : {}),
...(value.smart_tip_threshold !== undefined
? { smartTipThreshold: value.smart_tip_threshold }
: {}),
};
};
const toTipping = (
tipping: TerminalConfigurationConfigurationResourceTipping | undefined,
): TerminalTipping | undefined => {
if (tipping === undefined) return undefined;
const out: TerminalTipping = {};
for (const currency of TIPPING_CURRENCIES) {
const mapped = toTippingCurrency(tipping[currency]);
if (mapped !== undefined) out[currency] = mapped;
}
return Object.keys(out).length > 0 ? out : undefined;
};
const toWifiState = (
wifi: TerminalConfigurationConfigurationResourceWifiConfig | undefined,
): TerminalWifiState | undefined => {
if (wifi === undefined) return undefined;
return {
type: wifi.type,
...(wifi.enterprise_eap_peap !== undefined
? {
enterpriseEapPeap: {
ssid: wifi.enterprise_eap_peap.ssid,
username: wifi.enterprise_eap_peap.username,
caCertificateFile: wifi.enterprise_eap_peap.ca_certificate_file,
},
}
: {}),
...(wifi.enterprise_eap_tls !== undefined
? {
enterpriseEapTls: {
ssid: wifi.enterprise_eap_tls.ssid,
clientCertificateFile: wifi.enterprise_eap_tls.client_certificate_file,
privateKeyFile: wifi.enterprise_eap_tls.private_key_file,
caCertificateFile: wifi.enterprise_eap_tls.ca_certificate_file,
},
}
: {}),
...(wifi.personal_psk !== undefined ? { personalPsk: { ssid: wifi.personal_psk.ssid } } : {}),
};
};
const toAttrs = (configuration: StripeTerminalConfiguration): ConfigurationAttributes => {
const devices = {} as DeviceAttributes;
for (const [camel, snake] of DEVICE_MAP) {
devices[camel] = toDeviceState(configuration[snake]);
}
return {
id: configuration.id,
name: configuration.name ?? undefined,
isAccountDefault: isAccountDefault(configuration),
offline:
configuration.offline?.enabled == null
? undefined
: { enabled: configuration.offline.enabled },
tipping: toTipping(configuration.tipping),
rebootWindow:
configuration.reboot_window === undefined
? undefined
: {
startHour: configuration.reboot_window.start_hour,
endHour: configuration.reboot_window.end_hour,
},
cellular:
configuration.cellular === undefined
? undefined
: { enabled: configuration.cellular.enabled },
wifi: toWifiState(configuration.wifi),
livemode: configuration.livemode,
...devices,
};
};
const toWireTippingCurrency = (value: TerminalTippingCurrency) => ({
...(value.fixedAmounts !== undefined ? { fixed_amounts: value.fixedAmounts } : {}),
...(value.percentages !== undefined ? { percentages: value.percentages } : {}),
...(value.smartTipThreshold !== undefined
? { smart_tip_threshold: value.smartTipThreshold }
: {}),
});
const toWireTipping = (
tipping: TerminalTipping,
): CreateTerminalConfigurationRequestTippingCase0 => {
const out: CreateTerminalConfigurationRequestTippingCase0 = {};
for (const currency of TIPPING_CURRENCIES) {
const value = tipping[currency];
if (value !== undefined) {
out[currency] = toWireTippingCurrency(value);
}
}
return out;
};
const toWireWifi = (wifi: TerminalWifi): CreateTerminalConfigurationRequestWifiCase0 => ({
type: wifi.type,
...(wifi.enterpriseEapPeap !== undefined
? {
enterprise_eap_peap: {
ssid: wifi.enterpriseEapPeap.ssid,
username: wifi.enterpriseEapPeap.username,
password: wifi.enterpriseEapPeap.password,
...(wifi.enterpriseEapPeap.caCertificateFile !== undefined
? { ca_certificate_file: wifi.enterpriseEapPeap.caCertificateFile }
: {}),
},
}
: {}),
...(wifi.enterpriseEapTls !== undefined
? {
enterprise_eap_tls: {
ssid: wifi.enterpriseEapTls.ssid,
client_certificate_file: wifi.enterpriseEapTls.clientCertificateFile,
private_key_file: wifi.enterpriseEapTls.privateKeyFile,
...(wifi.enterpriseEapTls.caCertificateFile !== undefined
? { ca_certificate_file: wifi.enterpriseEapTls.caCertificateFile }
: {}),
...(wifi.enterpriseEapTls.privateKeyFilePassword !== undefined
? {
private_key_file_password: wifi.enterpriseEapTls.privateKeyFilePassword,
}
: {}),
},
}
: {}),
...(wifi.personalPsk !== undefined
? {
personal_psk: {
ssid: wifi.personalPsk.ssid,
password: wifi.personalPsk.password,
},
}
: {}),
});
const toWireDevice = (device: TerminalDeviceConfig) =>
device.splashscreen !== undefined ? { splashscreen: device.splashscreen } : {};
const wifiComparable = (wifi: TerminalWifi | TerminalWifiState | undefined): unknown => {
if (wifi === undefined) return undefined;
return {
type: wifi.type,
enterpriseEapPeap:
wifi.enterpriseEapPeap === undefined
? undefined
: {
ssid: wifi.enterpriseEapPeap.ssid,
username:
"username" in wifi.enterpriseEapPeap ? wifi.enterpriseEapPeap.username : undefined,
caCertificateFile: wifi.enterpriseEapPeap.caCertificateFile,
},
enterpriseEapTls:
wifi.enterpriseEapTls === undefined
? undefined
: {
ssid: wifi.enterpriseEapTls.ssid,
clientCertificateFile: wifi.enterpriseEapTls.clientCertificateFile,
privateKeyFile: wifi.enterpriseEapTls.privateKeyFile,
caCertificateFile: wifi.enterpriseEapTls.caCertificateFile,
},
personalPsk: wifi.personalPsk === undefined ? undefined : { ssid: wifi.personalPsk.ssid },
};
};
const pickSpecified = (desired: unknown, observed: unknown): unknown => {
if (desired === undefined) return undefined;
if (Array.isArray(desired)) {
if (!Array.isArray(observed)) return observed;
return desired.map((item, index) => pickSpecified(item, observed[index]));
}
if (
desired !== null &&
typeof desired === "object" &&
observed !== null &&
typeof observed === "object"
) {
const out: Record<string, unknown> = {};
for (const key of Object.keys(desired as Record<string, unknown>)) {
out[key] = pickSpecified(
(desired as Record<string, unknown>)[key],
(observed as Record<string, unknown>)[key],
);
}
return out;
}
return observed;
};
const nestedNeedSync = (desired: unknown, observed: unknown): boolean => {
if (desired === undefined) return false;
if (desired === null) return observed !== undefined;
return !deepEqual(desired, pickSpecified(desired, observed), {
stripNullish: true,
});
};
const isMissingConfiguration = isMissingStripeResource;
const getById = (configuration: string) =>
GetTerminalConfiguration({ configuration }).pipe(
Effect.map(asConfiguration),
Effect.catchIf(isMissingConfiguration, () => Effect.undefined),
);
const listNonDefault = Effect.fn(function* () {
const configurations: StripeTerminalConfiguration[] = [];
let startingAfter: string | undefined;
for (let page = 0; page < LIST_MAX_PAGES; page++) {
const response = yield* GetTerminalConfigurations({
is_account_default: false,
limit: LIST_PAGE_SIZE,
...(startingAfter !== undefined ? { starting_after: startingAfter } : {}),
});
configurations.push(...response.data);
if (!response.has_more || response.data.length === 0) {
break;
}
startingAfter = response.data[response.data.length - 1]?.id;
if (startingAfter === undefined) {
break;
}
}
return configurations.filter((configuration) => !isAccountDefault(configuration));
});
const findByName = Effect.fn(function* (name: string) {
const configurations = yield* listNonDefault();
return configurations.find((configuration) => (configuration.name ?? "") === name);
});
const observe = Effect.fn(function* (input: { id?: string; name?: string }) {
if (input.id !== undefined) {
const byId = yield* getById(input.id);
if (byId !== undefined) return byId;
}
if (input.name !== undefined) {
return yield* findByName(input.name);
}
return undefined;
});
type DeviceWire = { splashscreen?: string };
const specifiedDevices = (
news: TerminalConfigurationProps,
): Partial<Record<SnakeDeviceKey, DeviceWire | "">> => {
const payload: Partial<Record<SnakeDeviceKey, DeviceWire | "">> = {};
for (const [camel, snake] of DEVICE_MAP) {
const value = news[camel];
if (value === undefined) continue;
payload[snake] = value === null ? "" : toWireDevice(value);
}
return payload;
};
const toCreatePayload = (
name: string,
news: TerminalConfigurationProps,
): CreateTerminalConfigurationRequest => {
const devices = specifiedDevices(news);
const createDevices: Partial<Record<SnakeDeviceKey, DeviceWire>> = {};
for (const [snake, value] of Object.entries(devices) as Array<
[SnakeDeviceKey, DeviceWire | ""]
>) {
if (value !== "") createDevices[snake] = value;
}
return {
name,
...(news.offline != null ? { offline: news.offline } : {}),
...(news.tipping != null ? { tipping: toWireTipping(news.tipping) } : {}),
...(news.rebootWindow != null
? {
reboot_window: {
start_hour: news.rebootWindow.startHour,
end_hour: news.rebootWindow.endHour,
},
}
: {}),
...(news.cellular != null ? { cellular: news.cellular } : {}),
...(news.wifi != null ? { wifi: toWireWifi(news.wifi) } : {}),
...createDevices,
};
};
export const TerminalConfigurationProvider = () =>
Provider.succeed(TerminalConfiguration, {
stables: ["id", "livemode", "isAccountDefault"],
diff: Effect.fn(function* ({ news }) {
if (!isResolved(news)) return undefined;
return undefined;
}),
read: Effect.fn(function* ({ output }) {
const existing = yield* observe({
id: output?.id,
name: output?.name,
});
if (existing === undefined) return undefined;
const attrs = toAttrs(existing);
// No metadata. Identity is the Stripe id and unique name. Never
// take over the account default configuration.
return isAccountDefault(existing) ? Unowned(attrs) : attrs;
}),
list: Effect.fn(function* () {
// No metadata on this resource. Account-wide list is every
// non-default configuration so nuke can drain the account.
const configurations = yield* listNonDefault();
return configurations.map(toAttrs);
}),
reconcile: Effect.fn(function* ({ id, news, output, instanceId }) {
const name = yield* toName(id, news.name, output?.name);
let current = yield* observe({
id: output?.id,
name,
});
if (current !== undefined && isAccountDefault(current)) {
current = undefined;
}
if (current === undefined) {
current = yield* CreateTerminalConfiguration(toCreatePayload(name, news)).pipe(
withRequestOptions({
idempotencyKey: `alchemy-terminal-configuration-${instanceId}`,
}),
);
}
if (current === undefined) {
return yield* new TerminalConfigurationNotResolved({
configurationId: output?.id,
resourceName: name,
});
}
const attrs = toAttrs(current);
const nameChanged = (current.name ?? "") !== name;
const offlineChanged = nestedNeedSync(news.offline, attrs.offline);
const tippingChanged = nestedNeedSync(news.tipping, attrs.tipping);
const rebootWindowChanged = nestedNeedSync(news.rebootWindow, attrs.rebootWindow);
const cellularChanged = nestedNeedSync(news.cellular, attrs.cellular);
const wifiChanged =
news.wifi === null
? attrs.wifi !== undefined
: news.wifi !== undefined &&
nestedNeedSync(wifiComparable(news.wifi), wifiComparable(attrs.wifi));
const changedDevices: Partial<Record<SnakeDeviceKey, DeviceWire | "">> = {};
for (const [camel, snake] of DEVICE_MAP) {
const desired = news[camel];
if (desired === undefined) continue;
if (nestedNeedSync(desired, attrs[camel])) {
changedDevices[snake] = desired === null ? "" : toWireDevice(desired);
}
}
const devicesChanged = Object.keys(changedDevices).length > 0;
if (
!nameChanged &&
!offlineChanged &&
!tippingChanged &&
!rebootWindowChanged &&
!cellularChanged &&
!wifiChanged &&
!devicesChanged
) {
return attrs;
}
const updated = yield* UpdateTerminalConfiguration({
configuration: current.id,
...(nameChanged ? { name } : {}),
...(offlineChanged ? { offline: news.offline === null ? "" : news.offline! } : {}),
...(tippingChanged
? {
tipping: news.tipping === null ? "" : toWireTipping(news.tipping!),
}
: {}),
...(rebootWindowChanged
? {
reboot_window:
news.rebootWindow === null
? ""
: {
start_hour: news.rebootWindow!.startHour,
end_hour: news.rebootWindow!.endHour,
},
}
: {}),
...(cellularChanged ? { cellular: news.cellular === null ? "" : news.cellular! } : {}),
...(wifiChanged ? { wifi: news.wifi === null ? "" : toWireWifi(news.wifi!) } : {}),
...changedDevices,
});
const next = asConfiguration(updated);
if (next === undefined) {
return yield* new TerminalConfigurationNotResolved({
configurationId: current.id,
resourceName: name,
});
}
return toAttrs(next);
}),
delete: Effect.fn(function* ({ output }) {
const existing = yield* getById(output.id);
if (existing === undefined || isAccountDefault(existing)) return;
yield* DeleteTerminalConfiguration({
configuration: existing.id,
}).pipe(Effect.catchIf(isMissingConfiguration, () => Effect.void));
}),
});