import * as mq from "@distilled.cloud/aws/mq";
import { Unowned } from "alchemy/AdoptPolicy";
import { isResolved } from "alchemy/Diff";
import { createPhysicalName } from "alchemy/PhysicalName";
import * as Provider from "alchemy/Provider";
import { Resource } from "alchemy/Resource";
import { createInternalTags, hasAlchemyTags } from "alchemy/Tags";
import * as Data from "effect/Data";
import * as Effect from "effect/Effect";
import type { Providers } from "../Providers.ts";
import { syncMqTags, toTagRecord } from "./internal.ts";
export class ConfigurationUnexpectedResponse extends Data.TaggedError(
"ConfigurationUnexpectedResponse",
)<{
readonly message: string;
readonly cause?: unknown;
}> {}
export interface ConfigurationProps {
/**
* Name of the configuration (1-150 chars, `a-z A-Z 0-9 . _ ~ -`). If
* omitted a deterministic physical name is generated. The name is
* immutable — changing it replaces the configuration.
*/
configurationName?: string;
/**
* Broker engine the configuration targets. Immutable — changing it
* replaces the configuration.
*/
engineType: "ACTIVEMQ" | "RABBITMQ";
/**
* Broker engine version the configuration targets (e.g. `"5.18"` for
* ActiveMQ, `"3.13"` for RabbitMQ). Immutable — changing it replaces the
* configuration.
*/
engineVersion?: string;
/**
* Authentication strategy for the associated broker. Immutable —
* changing it replaces the configuration.
* @default "SIMPLE"
*/
authenticationStrategy?: "SIMPLE" | "LDAP";
/**
* The broker configuration document as plain text (ActiveMQ XML or
* RabbitMQ Cuttlefish). Alchemy base64-encodes it for the API. Supplying
* (or changing) `data` publishes a new configuration revision. Omitting
* it keeps the engine's default revision.
*/
data?: string;
/**
* Description recorded on the published revision. Only applied when `data`
* is also supplied (the API updates data + description together).
*/
description?: string;
/**
* User-defined tags for the configuration.
*/
tags?: Record<string, string>;
}
export interface Configuration extends Resource<
"AWS.MQ.Configuration",
ConfigurationProps,
{
/** Server-assigned unique id of the configuration (e.g. `c-1234...`). */
configurationId: string;
/** ARN of the configuration. */
configurationArn: string;
/** Name of the configuration. */
configurationName: string;
/** Latest published revision number. */
configurationRevision: number;
/** Broker engine the configuration targets (`ACTIVEMQ` or `RABBITMQ`). */
engineType: string;
/** Engine version the configuration targets. */
engineVersion: string | undefined;
},
never,
Providers
> {}
/**
* An Amazon MQ broker configuration — a versioned document (ActiveMQ XML or
* RabbitMQ Cuttlefish) that a {@link Broker} can reference to control
* engine-level settings. Each edit to `data` publishes a new immutable
* revision; a broker pins a specific `{ id, revision }` pair.
*
* ### Creating a Configuration
* **Example:** Default ActiveMQ Configuration
* ```typescript
* const config = yield* MQ.Configuration("BrokerConfig", {
* engineType: "ACTIVEMQ",
* engineVersion: "5.18",
* });
* ```
*
* **Example:** Custom ActiveMQ Configuration Document
* ```typescript
* const config = yield* MQ.Configuration("BrokerConfig", {
* engineType: "ACTIVEMQ",
* engineVersion: "5.18",
* description: "Enable statistics plugin",
* data: `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
* <broker xmlns="http://activemq.apache.org/schema/core">
* <plugins>
* <statisticsBrokerPlugin/>
* </plugins>
* </broker>`,
* });
* // config.configurationRevision -> 2 (the published revision)
* ```
*
* ### Attaching to a Broker
* **Example:** Reference a Configuration from a Broker
* ```typescript
* const broker = yield* MQ.Broker("Orders", {
* engineType: "ACTIVEMQ",
* engineVersion: "5.18",
* hostInstanceType: "mq.t3.micro",
* users: [{ username: "admin", password: Redacted.make("SuperSecretPassw0rd") }],
* configuration: {
* id: config.configurationId,
* revision: config.configurationRevision,
* },
* });
* ```
*
* @resource
*/
export const Configuration = Resource<Configuration>("AWS.MQ.Configuration");
const encodeData = (data: string): Effect.Effect<string> =>
Effect.sync(() => Buffer.from(data, "utf8").toString("base64"));
const decodeData = (data: string | undefined): Effect.Effect<string> =>
Effect.sync(() => (data === undefined ? "" : Buffer.from(data, "base64").toString("utf8")));
export const ConfigurationProvider = () =>
Provider.effect(
Configuration,
Effect.gen(function* () {
const toName = (id: string, props: Partial<ConfigurationProps>) =>
props.configurationName
? Effect.succeed(props.configurationName)
: createPhysicalName({ id, maxLength: 150 });
/** Read a configuration by id; a missing configuration reads as absent. */
const readConfiguration = Effect.fn(function* (configurationId: string) {
return yield* mq
.describeConfiguration({ ConfigurationId: configurationId })
.pipe(Effect.catchTag("NotFoundException", () => Effect.undefined));
});
/** Enumerate all configurations (listConfigurations is not paginated). */
const listAllConfigurations = Effect.fn(function* () {
const configs: mq.Configuration[] = [];
let nextToken: string | undefined;
// Bounded page walk — MQ terminates on an absent NextToken.
for (let page = 0; page < 20; page++) {
const response = yield* mq.listConfigurations({
MaxResults: 100,
NextToken: nextToken,
});
configs.push(...(response.Configurations ?? []));
nextToken = response.NextToken;
if (!nextToken) break;
}
return configs;
});
/** Find a live configuration by name. */
const findByName = Effect.fn(function* (name: string) {
const configs = yield* listAllConfigurations();
const summary = configs.find((c) => c.Name === name && c.Id);
if (!summary?.Id) return undefined;
return yield* readConfiguration(summary.Id);
});
const toAttrs = (config: mq.DescribeConfigurationResponse) => ({
configurationId: config.Id!,
configurationArn: config.Arn!,
configurationName: config.Name!,
configurationRevision: config.LatestRevision?.Revision ?? 1,
engineType: config.EngineType!,
engineVersion: config.EngineVersion,
});
return {
stables: ["configurationId", "configurationArn", "configurationName"],
diff: Effect.fn(function* ({ id, olds, news }) {
if (!isResolved(news)) return undefined;
if ((yield* toName(id, olds ?? {})) !== (yield* toName(id, news ?? {}))) {
return { action: "replace" } as const;
}
// Engine type, version, and auth strategy are fixed at creation.
if ((news.engineType ?? undefined) !== (olds?.engineType ?? undefined)) {
return { action: "replace" } as const;
}
if ((news.engineVersion ?? undefined) !== (olds?.engineVersion ?? undefined)) {
return { action: "replace" } as const;
}
if (
(news.authenticationStrategy ?? undefined) !==
(olds?.authenticationStrategy ?? undefined)
) {
return { action: "replace" } as const;
}
}),
read: Effect.fn(function* ({ id, olds, output }) {
const config = output?.configurationId
? yield* readConfiguration(output.configurationId)
: yield* findByName(yield* toName(id, olds ?? {}));
if (config === undefined) return undefined;
const attrs = toAttrs(config);
const tags = toTagRecord(config.Tags);
return (yield* hasAlchemyTags(id, tags)) ? attrs : Unowned(attrs);
}),
reconcile: Effect.fn(function* ({ id, news, output, session }) {
const name = output?.configurationName ?? (yield* toName(id, news));
const internalTags = yield* createInternalTags(id);
const desiredTags = { ...internalTags, ...news.tags };
// 1. Observe — cloud state is authoritative.
let observed = output?.configurationId
? yield* readConfiguration(output.configurationId)
: undefined;
if (observed === undefined) {
observed = yield* findByName(name);
}
// 2. Ensure — create if missing. createConfiguration seeds an
// initial default revision; `data` (if any) is published below.
if (observed === undefined) {
const created = yield* mq.createConfiguration({
Name: name,
EngineType: news.engineType,
EngineVersion: news.engineVersion,
AuthenticationStrategy: news.authenticationStrategy,
Tags: desiredTags,
});
observed = yield* readConfiguration(created.Id!);
if (observed === undefined) {
return yield* new ConfigurationUnexpectedResponse({
message: `MQ configuration '${name}' disappeared immediately after create`,
});
}
}
const configurationId = observed.Id!;
// 3. Sync configuration document — publish a new revision only when
// the desired `data` differs from the current latest revision.
if (news.data !== undefined) {
const revision = observed.LatestRevision?.Revision;
const current =
revision === undefined
? undefined
: yield* mq.describeConfigurationRevision({
ConfigurationId: configurationId,
ConfigurationRevision: String(revision),
});
const currentData = yield* decodeData(current?.Data);
if (currentData !== news.data) {
yield* mq.updateConfiguration({
ConfigurationId: configurationId,
Data: yield* encodeData(news.data),
Description: news.description,
});
}
}
// 3b. Sync tags — diff against OBSERVED cloud tags.
yield* syncMqTags(observed.Arn!, toTagRecord(observed.Tags), desiredTags);
// 4. Re-read for the fresh latest revision + tags.
const final = yield* readConfiguration(configurationId);
if (final === undefined) {
return yield* new ConfigurationUnexpectedResponse({
message: `MQ configuration '${name}' disappeared while reconciling`,
});
}
yield* session.note(name);
return toAttrs(final);
}),
delete: Effect.fn(function* ({ output }) {
yield* mq
.deleteConfiguration({ ConfigurationId: output.configurationId })
.pipe(Effect.catchTag("NotFoundException", () => Effect.void));
}),
list: () =>
Effect.gen(function* () {
const configs = yield* listAllConfigurations();
return configs.flatMap((c) =>
c.Id !== undefined && c.Arn !== undefined && c.Name !== undefined
? [
{
configurationId: c.Id,
configurationArn: c.Arn,
configurationName: c.Name,
configurationRevision: c.LatestRevision?.Revision ?? 1,
engineType: c.EngineType!,
engineVersion: c.EngineVersion,
},
]
: [],
);
}),
};
}),
);