@devries-cameron20 / t3code Mirror · read-only
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 04:45 UTC

main
ts 275 lines 9.42 KB
Raw
1 import * as backup from "@distilled.cloud/aws/backup";
2 import { isResolved } from "alchemy/Diff";
3 import { createPhysicalName } from "alchemy/PhysicalName";
4 import * as Provider from "alchemy/Provider";
5 import { Resource } from "alchemy/Resource";
6 import * as Effect from "effect/Effect";
7 import * as Schedule from "effect/Schedule";
8 import type { Providers } from "../Providers.ts";
9
10 /**
11 * A tag-based condition used to select resources for backup by matching the
12 * tags attached to them.
13 */
14 export interface BackupSelectionTagCondition {
15 /**
16 * How the tag is matched. `STRINGEQUALS` is the only supported operator
17 * for the legacy `listOfTags` selector.
18 */
19 conditionType?: "STRINGEQUALS" | (string & {});
20 /**
21 * The tag key to match, e.g. `aws:ResourceTag/backup`.
22 */
23 conditionKey: string;
24 /**
25 * The tag value to match.
26 */
27 conditionValue: string;
28 }
29
30 export interface BackupSelectionProps {
31 /**
32 * ID of the backup plan this selection assigns resources to. Typically the
33 * `backupPlanId` attribute of a {@link BackupPlan}.
34 *
35 * Changing the plan replaces the selection.
36 */
37 backupPlanId: string;
38 /**
39 * Display name for the selection. If omitted, a unique name is generated
40 * from the app, stage, and logical ID.
41 *
42 * A backup selection is immutable — changing the name replaces it.
43 */
44 selectionName?: string;
45 /**
46 * ARN of the IAM role AWS Backup assumes to create and manage backups on
47 * your behalf. The role's trust policy must allow `backup.amazonaws.com`.
48 *
49 * Immutable — changing the role replaces the selection.
50 */
51 iamRoleArn: string;
52 /**
53 * ARNs of the resources to assign to the backup plan. Use `["*"]` to
54 * assign all supported resources.
55 *
56 * Immutable — changing the resource list replaces the selection.
57 */
58 resources?: string[];
59 /**
60 * ARNs of resources to explicitly exclude from the plan.
61 *
62 * Immutable — changing this replaces the selection.
63 */
64 notResources?: string[];
65 /**
66 * Tag-based conditions selecting resources by their tags (legacy
67 * `ListOfTags` selector — conditions are ANDed together).
68 *
69 * Immutable — changing this replaces the selection.
70 */
71 listOfTags?: BackupSelectionTagCondition[];
72 }
73
74 export interface BackupSelection extends Resource<
75 "AWS.Backup.BackupSelection",
76 BackupSelectionProps,
77 {
78 /**
79 * Service-assigned unique ID of the selection.
80 */
81 selectionId: string;
82 /**
83 * Name of the selection.
84 */
85 selectionName: string;
86 /**
87 * ID of the backup plan the selection is attached to.
88 */
89 backupPlanId: string;
90 },
91 never,
92 Providers
93 > {}
94
95 /**
96 * An AWS Backup selection — assigns AWS resources to a {@link BackupPlan}
97 * either by explicit ARN or by matching resource tags, using an IAM role that
98 * AWS Backup assumes to perform the backups.
99 *
100 * A selection is immutable: any change to its name, role, or resource set
101 * replaces it.
102 *
103 * ### Assigning Resources
104 * **Example:** Assign resources by tag
105 * ```typescript
106 * import * as Backup from "@alchemy.run/aws/Backup";
107 *
108 * const selection = yield* Backup.BackupSelection("TaggedResources", {
109 * backupPlanId: plan.backupPlanId,
110 * iamRoleArn: backupRole.roleArn,
111 * listOfTags: [
112 * {
113 * conditionType: "STRINGEQUALS",
114 * conditionKey: "aws:ResourceTag/backup",
115 * conditionValue: "daily",
116 * },
117 * ],
118 * });
119 * ```
120 *
121 * **Example:** Assign resources by ARN
122 * ```typescript
123 * const selection = yield* Backup.BackupSelection("ExplicitResources", {
124 * backupPlanId: plan.backupPlanId,
125 * iamRoleArn: backupRole.roleArn,
126 * resources: [table.tableArn],
127 * });
128 * ```
129 *
130 * @resource
131 */
132 export const BackupSelection = Resource<BackupSelection>("AWS.Backup.BackupSelection");
133
134 // A freshly-created IAM role is not immediately assumable by AWS Backup, so
135 // CreateBackupSelection can transiently reject the role with
136 // InvalidParameterValueException. Retry on a bounded schedule. The explicit
137 // return annotation keeps `Retry.Return`'s conditional type out of the
138 // provider's declaration emit (see SecretsManager/Secret.ts).
139 const retryRolePropagation = <A, E extends { _tag: string }, R>(
140 eff: Effect.Effect<A, E, R>,
141 ): Effect.Effect<A, E, R> =>
142 eff.pipe(
143 Effect.retry({
144 while: (e: E) => e._tag === "InvalidParameterValueException",
145 schedule: Schedule.max([Schedule.fixed("3 seconds"), Schedule.recurs(10)]),
146 }),
147 );
148
149 export const BackupSelectionProvider = () =>
150 Provider.effect(
151 BackupSelection,
152 Effect.gen(function* () {
153 const createName = Effect.fn(function* (
154 id: string,
155 props: { selectionName?: string | undefined },
156 ) {
157 return props.selectionName ?? (yield* createPhysicalName({ id, maxLength: 50 }));
158 });
159
160 return BackupSelection.Provider.of({
161 stables: ["selectionId", "selectionName", "backupPlanId"],
162 // A selection is keyed by its parent plan; there is no account-wide
163 // enumeration API. Return empty and rely on read/reconcile by id.
164 list: () => Effect.succeed([]),
165 read: Effect.fn(function* ({ output }) {
166 if (!output?.selectionId || !output?.backupPlanId) return undefined;
167 // AWS Backup returns InvalidParameterValueException (not
168 // ResourceNotFoundException) for a selection id that no longer
169 // exists — treat both as "absent".
170 const found = yield* backup
171 .getBackupSelection({
172 BackupPlanId: output.backupPlanId,
173 SelectionId: output.selectionId,
174 })
175 .pipe(
176 Effect.catchTag(
177 ["ResourceNotFoundException", "InvalidParameterValueException"],
178 () => Effect.undefined,
179 ),
180 );
181 if (!found?.SelectionId) return undefined;
182 return {
183 selectionId: found.SelectionId,
184 selectionName: found.BackupSelection?.SelectionName ?? output.selectionName,
185 backupPlanId: output.backupPlanId,
186 };
187 }),
188 diff: Effect.fn(function* ({ id, news, olds }) {
189 if (!isResolved(news)) return undefined;
190 const oldName = yield* createName(id, olds);
191 const newName = yield* createName(id, news);
192 // The selection API has no update operation, so every meaningful
193 // change is a replacement.
194 if (
195 oldName !== newName ||
196 (olds.backupPlanId ?? "") !== (news.backupPlanId ?? "") ||
197 (olds.iamRoleArn ?? "") !== (news.iamRoleArn ?? "") ||
198 JSON.stringify(olds.resources ?? []) !== JSON.stringify(news.resources ?? []) ||
199 JSON.stringify(olds.notResources ?? []) !== JSON.stringify(news.notResources ?? []) ||
200 JSON.stringify(olds.listOfTags ?? []) !== JSON.stringify(news.listOfTags ?? [])
201 ) {
202 return { action: "replace" } as const;
203 }
204 }),
205 reconcile: Effect.fn(function* ({ id, news, output, session }) {
206 const name = output?.selectionName ?? (yield* createName(id, news));
207 const backupPlanId = news.backupPlanId;
208
209 // OBSERVE — confirm an existing selection by id; a selection is
210 // immutable so there is nothing to sync when it already exists.
211 if (output?.selectionId) {
212 const existing = yield* backup
213 .getBackupSelection({
214 BackupPlanId: backupPlanId,
215 SelectionId: output.selectionId,
216 })
217 .pipe(
218 Effect.catchTag(
219 ["ResourceNotFoundException", "InvalidParameterValueException"],
220 () => Effect.undefined,
221 ),
222 );
223 if (existing?.SelectionId) {
224 yield* session.note(existing.SelectionId);
225 return {
226 selectionId: existing.SelectionId,
227 selectionName: name,
228 backupPlanId,
229 };
230 }
231 }
232
233 // ENSURE — create (retrying while the IAM role propagates).
234 const created = yield* retryRolePropagation(
235 backup.createBackupSelection({
236 BackupPlanId: backupPlanId,
237 BackupSelection: {
238 SelectionName: name,
239 IamRoleArn: news.iamRoleArn!,
240 Resources: news.resources,
241 NotResources: news.notResources,
242 ListOfTags: news.listOfTags?.map((c) => ({
243 ConditionType: c.conditionType ?? "STRINGEQUALS",
244 ConditionKey: c.conditionKey,
245 ConditionValue: c.conditionValue,
246 })),
247 },
248 }),
249 );
250 yield* session.note(created.SelectionId!);
251 return {
252 selectionId: created.SelectionId!,
253 selectionName: name,
254 backupPlanId,
255 };
256 }),
257 delete: Effect.fn(function* ({ output }) {
258 // A missing selection deletes as InvalidParameterValueException; a
259 // deleted parent plan yields ResourceNotFoundException. Both are
260 // "already gone".
261 yield* backup
262 .deleteBackupSelection({
263 BackupPlanId: output.backupPlanId,
264 SelectionId: output.selectionId,
265 })
266 .pipe(
267 Effect.catchTag(
268 ["ResourceNotFoundException", "InvalidParameterValueException"],
269 () => Effect.void,
270 ),
271 );
272 }),
273 });
274 }),
275 );