import * as mm from "@distilled.cloud/aws/mailmanager";
import { Unowned } from "alchemy/AdoptPolicy";
import { isResolved } from "alchemy/Diff";
import * as Provider from "alchemy/Provider";
import { Resource } from "alchemy/Resource";
import { createInternalTags, createTagsList, hasAlchemyTags } from "alchemy/Tags";
import * as Data from "effect/Data";
import * as Effect from "effect/Effect";
import * as Stream from "effect/Stream";
import type { Providers } from "../Providers.ts";
import { readMailManagerTags, syncMailManagerTags } from "./internal.ts";
export class AddonInstanceUnexpectedResponse extends Data.TaggedError(
"AddonInstanceUnexpectedResponse",
)<{
readonly message: string;
readonly cause?: unknown;
}> {}
export interface AddonInstanceProps {
/**
* ID of the {@link AddonSubscription} this instance is created from.
* Immutable — changing the subscription replaces the instance.
*/
addonSubscriptionId: string;
/**
* Tags applied to the instance. Alchemy ownership tags are merged in
* automatically.
*/
tags?: Record<string, string>;
}
export interface AddonInstance extends Resource<
"AWS.MailManager.AddonInstance",
AddonInstanceProps,
{
/** Server-assigned ID of the Add On instance. */
addonInstanceId: string;
/** ARN of the Add On instance. */
addonInstanceArn: string;
/** ID of the subscription the instance was created from. */
addonSubscriptionId: string;
/** Name of the Add On product. */
addonName: string | undefined;
},
never,
Providers
> {}
/**
* An SES Mail Manager Add On instance — a usable deployment of a subscribed
* Add On that rule-set conditions and traffic-policy statements reference as
* an analyzer.
*
* Instances are immutable after creation (only tags update in place).
* ### Creating Add On Instances
* **Example:** Instance from a Subscription
* ```typescript
* import * as MailManager from "@alchemy.run/aws/MailManager";
*
* const subscription = yield* MailManager.AddonSubscription("Spamhaus", {
* addonName: "SPAMHAUS_DBL",
* });
* const instance = yield* MailManager.AddonInstance("SpamhausInstance", {
* addonSubscriptionId: subscription.addonSubscriptionId,
* });
* ```
*
* ### Referencing from a Traffic Policy
* **Example:** Analyzer Condition
* ```typescript
* const policy = yield* MailManager.TrafficPolicy("Edge", {
* defaultAction: "ALLOW",
* policyStatements: [
* {
* Action: "DENY",
* Conditions: [
* {
* BooleanExpression: {
* Evaluate: {
* Analysis: {
* Analyzer: instance.addonInstanceArn,
* ResultField: "IN_DBL",
* },
* },
* Operator: "IS_TRUE",
* },
* },
* ],
* },
* ],
* });
* ```
*
* @resource
*/
export const AddonInstance = Resource<AddonInstance>("AWS.MailManager.AddonInstance");
export const AddonInstanceProvider = () =>
Provider.effect(
AddonInstance,
Effect.gen(function* () {
const getById = (addonInstanceId: string) =>
mm
.getAddonInstance({ AddonInstanceId: addonInstanceId })
.pipe(Effect.catchTag("ResourceNotFoundException", () => Effect.undefined));
const listAll = mm.listAddonInstances.pages({}).pipe(
Stream.runCollect,
Effect.map((chunk) => Array.from(chunk).flatMap((page) => page.AddonInstances ?? [])),
);
// Instances have no user-supplied name — recover identity after a lost
// state write by searching for our ownership tags.
const findByAlchemyTags = Effect.fn(function* (id: string) {
const instances = yield* listAll;
for (const instance of instances) {
if (instance.AddonInstanceArn === undefined) continue;
const tags = yield* readMailManagerTags(instance.AddonInstanceArn);
if (yield* hasAlchemyTags(id, tags)) return instance;
}
return undefined;
});
const toAttrs = (instance: mm.AddonInstance) =>
instance.AddonInstanceId !== undefined &&
instance.AddonInstanceArn !== undefined &&
instance.AddonSubscriptionId !== undefined
? {
addonInstanceId: instance.AddonInstanceId,
addonInstanceArn: instance.AddonInstanceArn,
addonSubscriptionId: instance.AddonSubscriptionId,
addonName: instance.AddonName,
}
: undefined;
const observe = Effect.fn(function* (
id: string,
output: AddonInstance["Attributes"] | undefined,
) {
if (output?.addonInstanceId !== undefined) {
const found = yield* getById(output.addonInstanceId);
if (found !== undefined) {
return {
AddonInstanceId: output.addonInstanceId,
AddonInstanceArn: found.AddonInstanceArn,
AddonSubscriptionId: found.AddonSubscriptionId,
AddonName: found.AddonName,
} satisfies mm.AddonInstance;
}
}
return yield* findByAlchemyTags(id);
});
return AddonInstance.Provider.of({
stables: ["addonInstanceId", "addonInstanceArn", "addonSubscriptionId", "addonName"],
list: () =>
listAll.pipe(
Effect.map((instances) =>
instances.flatMap((i) => {
const attrs = toAttrs(i);
return attrs === undefined ? [] : [attrs];
}),
),
),
read: Effect.fn(function* ({ id, output }) {
const instance = yield* observe(id, output);
if (instance === undefined) return undefined;
const attrs = toAttrs(instance);
if (attrs === undefined) return undefined;
const tags = yield* readMailManagerTags(attrs.addonInstanceArn);
return (yield* hasAlchemyTags(id, tags)) ? attrs : Unowned(attrs);
}),
// The subscription is create-only — changing it replaces the
// instance.
diff: Effect.fn(function* ({ news, olds }) {
if (!isResolved(news)) return undefined;
if (olds !== undefined && olds.addonSubscriptionId !== news.addonSubscriptionId) {
return { action: "replace" } as const;
}
}),
reconcile: Effect.fn(function* ({ id, news, output, session }) {
const internalTags = yield* createInternalTags(id);
const desiredTags = { ...news.tags, ...internalTags };
// 1. OBSERVE — by cached id, falling back to an ownership-tag
// search.
let instance = yield* observe(id, output);
// 2. ENSURE — create if missing; a Conflict race re-observes via
// the tag search.
if (instance === undefined) {
yield* session.note(
`creating Add On instance for subscription ${news.addonSubscriptionId}`,
);
const created = yield* mm
.createAddonInstance({
AddonSubscriptionId: news.addonSubscriptionId,
Tags: createTagsList(desiredTags),
})
.pipe(Effect.catchTag("ConflictException", () => Effect.undefined));
if (created !== undefined) {
const found = yield* getById(created.AddonInstanceId);
instance = {
AddonInstanceId: created.AddonInstanceId,
AddonInstanceArn: found?.AddonInstanceArn,
AddonSubscriptionId: found?.AddonSubscriptionId ?? news.addonSubscriptionId,
AddonName: found?.AddonName,
};
} else {
instance = yield* findByAlchemyTags(id);
}
}
const attrs = instance !== undefined ? toAttrs(instance) : undefined;
if (attrs === undefined) {
return yield* new AddonInstanceUnexpectedResponse({
message: `Mail Manager Add On instance for subscription '${news.addonSubscriptionId}' not found after create`,
});
}
// 3. SYNC — only tags are mutable.
yield* syncMailManagerTags(attrs.addonInstanceArn, desiredTags);
yield* session.note(attrs.addonInstanceId);
return attrs;
}),
delete: Effect.fn(function* ({ output }) {
// DeleteAddonInstance is natively idempotent — deleting a
// nonexistent instance succeeds (verified live).
yield* mm
.deleteAddonInstance({ AddonInstanceId: output.addonInstanceId })
.pipe(Effect.asVoid);
}),
});
}),
);