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

main
ts 241 lines 8.49 KB
Raw
1 import * as mm from "@distilled.cloud/aws/mailmanager";
2 import { Unowned } from "alchemy/AdoptPolicy";
3 import { isResolved } from "alchemy/Diff";
4 import * as Provider from "alchemy/Provider";
5 import { Resource } from "alchemy/Resource";
6 import { createInternalTags, createTagsList, hasAlchemyTags } from "alchemy/Tags";
7 import * as Data from "effect/Data";
8 import * as Effect from "effect/Effect";
9 import * as Stream from "effect/Stream";
10 import type { Providers } from "../Providers.ts";
11 import { readMailManagerTags, syncMailManagerTags } from "./internal.ts";
12
13 export class AddonInstanceUnexpectedResponse extends Data.TaggedError(
14 "AddonInstanceUnexpectedResponse",
15 )<{
16 readonly message: string;
17 readonly cause?: unknown;
18 }> {}
19
20 export interface AddonInstanceProps {
21 /**
22 * ID of the {@link AddonSubscription} this instance is created from.
23 * Immutable — changing the subscription replaces the instance.
24 */
25 addonSubscriptionId: string;
26 /**
27 * Tags applied to the instance. Alchemy ownership tags are merged in
28 * automatically.
29 */
30 tags?: Record<string, string>;
31 }
32
33 export interface AddonInstance extends Resource<
34 "AWS.MailManager.AddonInstance",
35 AddonInstanceProps,
36 {
37 /** Server-assigned ID of the Add On instance. */
38 addonInstanceId: string;
39 /** ARN of the Add On instance. */
40 addonInstanceArn: string;
41 /** ID of the subscription the instance was created from. */
42 addonSubscriptionId: string;
43 /** Name of the Add On product. */
44 addonName: string | undefined;
45 },
46 never,
47 Providers
48 > {}
49
50 /**
51 * An SES Mail Manager Add On instance — a usable deployment of a subscribed
52 * Add On that rule-set conditions and traffic-policy statements reference as
53 * an analyzer.
54 *
55 * Instances are immutable after creation (only tags update in place).
56 * ### Creating Add On Instances
57 * **Example:** Instance from a Subscription
58 * ```typescript
59 * import * as MailManager from "@alchemy.run/aws/MailManager";
60 *
61 * const subscription = yield* MailManager.AddonSubscription("Spamhaus", {
62 * addonName: "SPAMHAUS_DBL",
63 * });
64 * const instance = yield* MailManager.AddonInstance("SpamhausInstance", {
65 * addonSubscriptionId: subscription.addonSubscriptionId,
66 * });
67 * ```
68 *
69 * ### Referencing from a Traffic Policy
70 * **Example:** Analyzer Condition
71 * ```typescript
72 * const policy = yield* MailManager.TrafficPolicy("Edge", {
73 * defaultAction: "ALLOW",
74 * policyStatements: [
75 * {
76 * Action: "DENY",
77 * Conditions: [
78 * {
79 * BooleanExpression: {
80 * Evaluate: {
81 * Analysis: {
82 * Analyzer: instance.addonInstanceArn,
83 * ResultField: "IN_DBL",
84 * },
85 * },
86 * Operator: "IS_TRUE",
87 * },
88 * },
89 * ],
90 * },
91 * ],
92 * });
93 * ```
94 *
95 * @resource
96 */
97 export const AddonInstance = Resource<AddonInstance>("AWS.MailManager.AddonInstance");
98
99 export const AddonInstanceProvider = () =>
100 Provider.effect(
101 AddonInstance,
102 Effect.gen(function* () {
103 const getById = (addonInstanceId: string) =>
104 mm
105 .getAddonInstance({ AddonInstanceId: addonInstanceId })
106 .pipe(Effect.catchTag("ResourceNotFoundException", () => Effect.undefined));
107
108 const listAll = mm.listAddonInstances.pages({}).pipe(
109 Stream.runCollect,
110 Effect.map((chunk) => Array.from(chunk).flatMap((page) => page.AddonInstances ?? [])),
111 );
112
113 // Instances have no user-supplied name — recover identity after a lost
114 // state write by searching for our ownership tags.
115 const findByAlchemyTags = Effect.fn(function* (id: string) {
116 const instances = yield* listAll;
117 for (const instance of instances) {
118 if (instance.AddonInstanceArn === undefined) continue;
119 const tags = yield* readMailManagerTags(instance.AddonInstanceArn);
120 if (yield* hasAlchemyTags(id, tags)) return instance;
121 }
122 return undefined;
123 });
124
125 const toAttrs = (instance: mm.AddonInstance) =>
126 instance.AddonInstanceId !== undefined &&
127 instance.AddonInstanceArn !== undefined &&
128 instance.AddonSubscriptionId !== undefined
129 ? {
130 addonInstanceId: instance.AddonInstanceId,
131 addonInstanceArn: instance.AddonInstanceArn,
132 addonSubscriptionId: instance.AddonSubscriptionId,
133 addonName: instance.AddonName,
134 }
135 : undefined;
136
137 const observe = Effect.fn(function* (
138 id: string,
139 output: AddonInstance["Attributes"] | undefined,
140 ) {
141 if (output?.addonInstanceId !== undefined) {
142 const found = yield* getById(output.addonInstanceId);
143 if (found !== undefined) {
144 return {
145 AddonInstanceId: output.addonInstanceId,
146 AddonInstanceArn: found.AddonInstanceArn,
147 AddonSubscriptionId: found.AddonSubscriptionId,
148 AddonName: found.AddonName,
149 } satisfies mm.AddonInstance;
150 }
151 }
152 return yield* findByAlchemyTags(id);
153 });
154
155 return AddonInstance.Provider.of({
156 stables: ["addonInstanceId", "addonInstanceArn", "addonSubscriptionId", "addonName"],
157
158 list: () =>
159 listAll.pipe(
160 Effect.map((instances) =>
161 instances.flatMap((i) => {
162 const attrs = toAttrs(i);
163 return attrs === undefined ? [] : [attrs];
164 }),
165 ),
166 ),
167
168 read: Effect.fn(function* ({ id, output }) {
169 const instance = yield* observe(id, output);
170 if (instance === undefined) return undefined;
171 const attrs = toAttrs(instance);
172 if (attrs === undefined) return undefined;
173 const tags = yield* readMailManagerTags(attrs.addonInstanceArn);
174 return (yield* hasAlchemyTags(id, tags)) ? attrs : Unowned(attrs);
175 }),
176
177 // The subscription is create-only — changing it replaces the
178 // instance.
179 diff: Effect.fn(function* ({ news, olds }) {
180 if (!isResolved(news)) return undefined;
181 if (olds !== undefined && olds.addonSubscriptionId !== news.addonSubscriptionId) {
182 return { action: "replace" } as const;
183 }
184 }),
185
186 reconcile: Effect.fn(function* ({ id, news, output, session }) {
187 const internalTags = yield* createInternalTags(id);
188 const desiredTags = { ...news.tags, ...internalTags };
189
190 // 1. OBSERVE — by cached id, falling back to an ownership-tag
191 // search.
192 let instance = yield* observe(id, output);
193
194 // 2. ENSURE — create if missing; a Conflict race re-observes via
195 // the tag search.
196 if (instance === undefined) {
197 yield* session.note(
198 `creating Add On instance for subscription ${news.addonSubscriptionId}`,
199 );
200 const created = yield* mm
201 .createAddonInstance({
202 AddonSubscriptionId: news.addonSubscriptionId,
203 Tags: createTagsList(desiredTags),
204 })
205 .pipe(Effect.catchTag("ConflictException", () => Effect.undefined));
206 if (created !== undefined) {
207 const found = yield* getById(created.AddonInstanceId);
208 instance = {
209 AddonInstanceId: created.AddonInstanceId,
210 AddonInstanceArn: found?.AddonInstanceArn,
211 AddonSubscriptionId: found?.AddonSubscriptionId ?? news.addonSubscriptionId,
212 AddonName: found?.AddonName,
213 };
214 } else {
215 instance = yield* findByAlchemyTags(id);
216 }
217 }
218 const attrs = instance !== undefined ? toAttrs(instance) : undefined;
219 if (attrs === undefined) {
220 return yield* new AddonInstanceUnexpectedResponse({
221 message: `Mail Manager Add On instance for subscription '${news.addonSubscriptionId}' not found after create`,
222 });
223 }
224
225 // 3. SYNC — only tags are mutable.
226 yield* syncMailManagerTags(attrs.addonInstanceArn, desiredTags);
227
228 yield* session.note(attrs.addonInstanceId);
229 return attrs;
230 }),
231
232 delete: Effect.fn(function* ({ output }) {
233 // DeleteAddonInstance is natively idempotent — deleting a
234 // nonexistent instance succeeds (verified live).
235 yield* mm
236 .deleteAddonInstance({ AddonInstanceId: output.addonInstanceId })
237 .pipe(Effect.asVoid);
238 }),
239 });
240 }),
241 );