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

main
ts 250 lines 8.22 KB
Raw
1 import * as mm from "@distilled.cloud/aws/mailmanager";
2 import { Unowned } from "alchemy/AdoptPolicy";
3 import { createPhysicalName } from "alchemy/PhysicalName";
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, sameShape, syncMailManagerTags } from "./internal.ts";
12
13 export class RelayUnexpectedResponse extends Data.TaggedError("RelayUnexpectedResponse")<{
14 readonly message: string;
15 readonly cause?: unknown;
16 }> {}
17
18 export interface RelayProps {
19 /**
20 * Name of the relay. If omitted, a deterministic physical name is
21 * generated from the app, stage, and logical ID. Renames apply in place.
22 */
23 relayName?: string;
24 /**
25 * Hostname of the downstream SMTP server emails are relayed to. Updates
26 * apply in place.
27 */
28 serverName: string;
29 /**
30 * Port of the downstream SMTP server (e.g. 25, 587). Updates apply in
31 * place.
32 */
33 serverPort: number;
34 /**
35 * How Mail Manager authenticates to the downstream server: a Secrets
36 * Manager secret ARN holding SMTP credentials, or explicit
37 * `{ NoAuthentication: {} }`. Updates apply in place.
38 */
39 authentication: mm.RelayAuthentication;
40 /**
41 * Tags applied to the relay. Alchemy ownership tags are merged in
42 * automatically.
43 */
44 tags?: Record<string, string>;
45 }
46
47 export interface Relay extends Resource<
48 "AWS.MailManager.Relay",
49 RelayProps,
50 {
51 /** Server-assigned ID of the relay. */
52 relayId: string;
53 /** ARN of the relay. */
54 relayArn: string;
55 /** Name of the relay. */
56 relayName: string;
57 },
58 never,
59 Providers
60 > {}
61
62 /**
63 * An SES Mail Manager relay — a downstream SMTP destination that rule-set
64 * `Relay` actions forward incoming email to (e.g. an on-prem Exchange
65 * server or a third-party filter).
66 *
67 * All aspects (name, server, port, authentication, tags) update in place.
68 * ### Creating Relays
69 * **Example:** Unauthenticated Relay
70 * ```typescript
71 * import * as MailManager from "@alchemy.run/aws/MailManager";
72 *
73 * const relay = yield* MailManager.Relay("Downstream", {
74 * serverName: "smtp.example.com",
75 * serverPort: 25,
76 * authentication: { NoAuthentication: {} },
77 * });
78 * ```
79 *
80 * **Example:** Authenticated Relay
81 * ```typescript
82 * const relay = yield* MailManager.Relay("Downstream", {
83 * serverName: "smtp.example.com",
84 * serverPort: 587,
85 * authentication: { SecretArn: secret.secretArn },
86 * });
87 * ```
88 *
89 * ### Using in a Rule Set
90 * **Example:** Relay Action
91 * ```typescript
92 * const ruleSet = yield* MailManager.RuleSet("Inbound", {
93 * rules: [
94 * {
95 * Name: "RelayAll",
96 * Actions: [{ Relay: { Relay: relay.relayId } }],
97 * },
98 * ],
99 * });
100 * ```
101 *
102 * @resource
103 */
104 export const Relay = Resource<Relay>("AWS.MailManager.Relay");
105
106 export const RelayProvider = () =>
107 Provider.effect(
108 Relay,
109 Effect.gen(function* () {
110 const createName = Effect.fn(function* (id: string, props: { relayName?: string }) {
111 return props.relayName ?? (yield* createPhysicalName({ id, maxLength: 100 }));
112 });
113
114 const getById = (relayId: string) =>
115 mm
116 .getRelay({ RelayId: relayId })
117 .pipe(Effect.catchTag("ResourceNotFoundException", () => Effect.undefined));
118
119 const findByName = (name: string) =>
120 mm.listRelays.pages({}).pipe(
121 Stream.runCollect,
122 Effect.map((chunk) =>
123 Array.from(chunk)
124 .flatMap((page) => page.Relays ?? [])
125 .find((r) => r.RelayName === name),
126 ),
127 );
128
129 const observe = Effect.fn(function* (output: Relay["Attributes"] | undefined, name: string) {
130 if (output?.relayId !== undefined) {
131 const found = yield* getById(output.relayId);
132 if (found !== undefined) return found;
133 }
134 const summary = yield* findByName(name);
135 if (summary?.RelayId === undefined) return undefined;
136 return yield* getById(summary.RelayId);
137 });
138
139 const toAttrs = Effect.fn(function* (relay: mm.GetRelayResponse) {
140 if (relay.RelayArn === undefined || relay.RelayName === undefined) {
141 return yield* new RelayUnexpectedResponse({
142 message: `Mail Manager relay '${relay.RelayId}' returned without ARN/name`,
143 });
144 }
145 return {
146 relayId: relay.RelayId,
147 relayArn: relay.RelayArn,
148 relayName: relay.RelayName,
149 };
150 });
151
152 return Relay.Provider.of({
153 stables: ["relayId", "relayArn"],
154
155 list: () =>
156 mm.listRelays.pages({}).pipe(
157 Stream.runCollect,
158 Effect.flatMap((chunk) =>
159 Effect.forEach(
160 Array.from(chunk)
161 .flatMap((page) => page.Relays ?? [])
162 .flatMap((r) => (r.RelayId !== undefined ? [r.RelayId] : [])),
163 (relayId) => getById(relayId),
164 ),
165 ),
166 Effect.flatMap((results) =>
167 Effect.forEach(
168 results.flatMap((r) => (r === undefined ? [] : [r])),
169 (r) => toAttrs(r),
170 ),
171 ),
172 ),
173
174 read: Effect.fn(function* ({ id, olds, output }) {
175 const name = output?.relayName ?? (yield* createName(id, olds ?? {}));
176 const relay = yield* observe(output, name);
177 if (relay === undefined) return undefined;
178 const attrs = yield* toAttrs(relay);
179 const tags = yield* readMailManagerTags(attrs.relayArn);
180 return (yield* hasAlchemyTags(id, tags)) ? attrs : Unowned(attrs);
181 }),
182
183 // Every prop updates in place — no replacement triggers, so the
184 // engine's default update path applies (no diff needed).
185
186 reconcile: Effect.fn(function* ({ id, news, output, session }) {
187 const name = yield* createName(id, news);
188 const internalTags = yield* createInternalTags(id);
189 const desiredTags = { ...news.tags, ...internalTags };
190
191 // 1. OBSERVE.
192 let relay = yield* observe(output, name);
193
194 // 2. ENSURE — create if missing; a Conflict race re-observes.
195 if (relay === undefined) {
196 yield* session.note(`creating relay ${name}`);
197 const created = yield* mm
198 .createRelay({
199 RelayName: name,
200 ServerName: news.serverName,
201 ServerPort: news.serverPort,
202 Authentication: news.authentication,
203 Tags: createTagsList(desiredTags),
204 })
205 .pipe(Effect.catchTag("ConflictException", () => Effect.undefined));
206 relay =
207 created !== undefined
208 ? yield* getById(created.RelayId)
209 : yield* observe(undefined, name);
210 }
211 if (relay === undefined) {
212 return yield* new RelayUnexpectedResponse({
213 message: `Mail Manager relay '${name}' not found after create`,
214 });
215 }
216
217 // 3. SYNC — diff OBSERVED state against desired; apply only the
218 // delta.
219 if (
220 relay.RelayName !== name ||
221 relay.ServerName !== news.serverName ||
222 relay.ServerPort !== news.serverPort ||
223 !sameShape(relay.Authentication, news.authentication)
224 ) {
225 yield* mm.updateRelay({
226 RelayId: relay.RelayId,
227 RelayName: name,
228 ServerName: news.serverName,
229 ServerPort: news.serverPort,
230 Authentication: news.authentication,
231 });
232 }
233
234 // 3b. SYNC TAGS.
235 const attrs = yield* toAttrs(relay);
236 yield* syncMailManagerTags(attrs.relayArn, desiredTags);
237
238 yield* session.note(attrs.relayId);
239 return { ...attrs, relayName: name };
240 }),
241
242 delete: Effect.fn(function* ({ output }) {
243 yield* mm.deleteRelay({ RelayId: output.relayId }).pipe(
244 Effect.asVoid,
245 Effect.catchTag("ResourceNotFoundException", () => Effect.void),
246 );
247 }),
248 });
249 }),
250 );