alchemy-effect 0.5.0 → 0.6.2

package/src/AWS/SNS/TagResource.ts

@@ -0,0 +1,66 @@
+import * as sns from "@distilled.cloud/aws/sns";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Binding from "../../Binding.ts";
+import { isFunction } from "../Lambda/Function.ts";
+import type { Topic } from "./Topic.ts";
+
+export interface TagResourceRequest extends Omit<
+  sns.TagResourceRequest,
+  "ResourceArn"
+> {}
+
+export class TagResource extends Binding.Service<
+  TagResource,
+  (
+    topic: Topic,
+  ) => Effect.Effect<
+    (
+      request: TagResourceRequest,
+    ) => Effect.Effect<sns.TagResourceResponse, sns.TagResourceError>
+  >
+>()("AWS.SNS.TagResource") {}
+
+export const TagResourceLive = Layer.effect(
+  TagResource,
+  Effect.gen(function* () {
+    const Policy = yield* TagResourcePolicy;
+    const tagResource = yield* sns.tagResource;
+
+    return Effect.fn(function* (topic: Topic) {
+      const TopicArn = yield* topic.topicArn;
+      yield* Policy(topic);
+      return Effect.fn(function* (request: TagResourceRequest) {
+        return yield* tagResource({
+          ...request,
+          ResourceArn: yield* TopicArn,
+        });
+      });
+    });
+  }),
+);
+
+export class TagResourcePolicy extends Binding.Policy<
+  TagResourcePolicy,
+  (topic: Topic) => Effect.Effect<void>
+>()("AWS.SNS.TagResource") {}
+
+export const TagResourcePolicyLive = TagResourcePolicy.layer.succeed(
+  Effect.fn(function* (host, topic) {
+    if (isFunction(host)) {
+      yield* host.bind`Allow(${host}, AWS.SNS.TagResource(${topic}))`({
+        policyStatements: [
+          {
+            Effect: "Allow",
+            Action: ["sns:TagResource"],
+            Resource: [topic.topicArn],
+          },
+        ],
+      });
+    } else {
+      return yield* Effect.die(
+        `TagResourcePolicy does not support runtime '${host.Type}'`,
+      );
+    }
+  }),
+);

package/src/AWS/SNS/Topic.ts

@@ -0,0 +1,363 @@
+import * as sns from "@distilled.cloud/aws/sns";
+import * as Effect from "effect/Effect";
+import { isResolved } from "../../Diff.ts";
+import { createPhysicalName } from "../../PhysicalName.ts";
+import { Resource } from "../../Resource.ts";
+import { createInternalTags, createTagsList, diffTags } from "../../Tags.ts";
+import type { AccountID } from "../Account.ts";
+import type { RegionID } from "../Region.ts";
+
+export type TopicName = string;
+export type TopicArn = `arn:aws:sns:${RegionID}:${AccountID}:${TopicName}`;
+
+export interface TopicProps {
+  /**
+   * Name of the topic.
+   * @default ${app}-${stage}-${id}?.fifo
+   */
+  topicName?: string;
+  /**
+   * Whether to create a FIFO topic.
+   * @default false
+   */
+  fifo?: boolean;
+  /**
+   * Raw SNS topic attributes keyed by AWS attribute name.
+   * Use this for delivery policies, tracing, KMS, signatures, archive policy, and
+   * other SNS topic attributes not modeled as first-class props.
+   */
+  attributes?: Record<string, string>;
+  /**
+   * SNS data protection policy JSON for the topic.
+   *
+   * TODO(sam): should this be a typed object that we serialize/deserialize?
+   */
+  dataProtectionPolicy?: string;
+  /**
+   * User-defined tags to apply to the topic.
+   */
+  tags?: Record<string, string>;
+}
+
+export interface Topic extends Resource<
+  "AWS.SNS.Topic",
+  TopicProps,
+  {
+    topicArn: TopicArn;
+    topicName: TopicName;
+    fifo: boolean;
+    attributes: Record<string, string>;
+    dataProtectionPolicy: string | undefined;
+    tags: Record<string, string>;
+  }
+> {}
+
+/**
+ * An Amazon SNS topic for fan-out messaging and notifications.
+ *
+ * `Topic` owns the SNS topic lifecycle while raw AWS topic attributes remain
+ * available through the `attributes` prop so the full core pub/sub surface can be
+ * configured without waiting on additional typed wrappers.
+ *
+ * @section Creating Topics
+ * @example Standard Topic
+ * ```typescript
+ * const topic = yield* Topic("OrdersTopic", {
+ *   topicName: "orders-events",
+ * });
+ * ```
+ *
+ * @example FIFO Topic
+ * ```typescript
+ * const topic = yield* Topic("OrdersFifoTopic", {
+ *   fifo: true,
+ *   attributes: {
+ *     ContentBasedDeduplication: "true",
+ *   },
+ * });
+ * ```
+ *
+ * @section Runtime Publishing
+ * @example Publish from a Lambda Function
+ * ```typescript
+ * const publish = yield* SNS.Publish.bind(topic);
+ *
+ * yield* publish({
+ *   Message: JSON.stringify({ orderId: "123" }),
+ *   Subject: "OrderCreated",
+ * });
+ * ```
+ */
+export const Topic = Resource<Topic>("AWS.SNS.Topic");
+
+export const TopicProvider = () =>
+  Topic.provider.succeed({
+    read: Effect.fn(function* ({ id, olds, output }) {
+      const topicName =
+        output?.topicName ?? (yield* toTopicName(id, olds ?? {}));
+
+      return yield* readTopic({
+        id,
+        topicArn: output?.topicArn,
+        topicName,
+      });
+    }),
+    stables: ["topicArn", "topicName", "fifo"],
+    diff: Effect.fn(function* ({ id, news = {}, olds = {} }) {
+      if (!isResolved(news)) return undefined;
+      if ((news.fifo ?? false) !== (olds.fifo ?? false)) {
+        return { action: "replace" } as const;
+      }
+
+      const oldTopicName = yield* toTopicName(id, olds);
+      const newTopicName = yield* toTopicName(id, news);
+
+      if (oldTopicName !== newTopicName) {
+        return { action: "replace" } as const;
+      }
+
+      if (
+        olds.dataProtectionPolicy !== undefined &&
+        news.dataProtectionPolicy === undefined
+      ) {
+        return { action: "replace" } as const;
+      }
+    }),
+    create: Effect.fn(function* ({ id, news = {}, session }) {
+      const topicName = yield* toTopicName(id, news);
+      const tags = {
+        ...(yield* createInternalTags(id)),
+        ...news.tags,
+      };
+
+      const response = yield* sns.createTopic({
+        Name: topicName,
+        Attributes: toAttributes(news),
+        Tags: createTagsList(tags),
+        DataProtectionPolicy: news.dataProtectionPolicy,
+      });
+
+      const topicArn = response.TopicArn;
+
+      if (!topicArn) {
+        return yield* Effect.die(new Error(`createTopic returned no ARN`));
+      }
+
+      yield* session.note(topicArn);
+
+      return {
+        topicArn: topicArn as TopicArn,
+        topicName,
+        fifo: news.fifo ?? false,
+        attributes: toAttributes(news),
+        dataProtectionPolicy: news.dataProtectionPolicy,
+        tags,
+      };
+    }),
+    update: Effect.fn(function* ({
+      id,
+      news = {},
+      olds = {},
+      output,
+      session,
+    }) {
+      const newAttributes = toAttributes(news);
+      const oldAttributes = toAttributes(olds);
+
+      for (const [name, value] of Object.entries(newAttributes)) {
+        if (oldAttributes[name] !== value) {
+          yield* sns.setTopicAttributes({
+            TopicArn: output.topicArn,
+            AttributeName: name,
+            AttributeValue: value,
+          });
+        }
+      }
+
+      for (const name of Object.keys(oldAttributes)) {
+        if (!(name in newAttributes)) {
+          yield* sns.setTopicAttributes({
+            TopicArn: output.topicArn,
+            AttributeName: name,
+          });
+        }
+      }
+
+      const newTags = {
+        ...(yield* createInternalTags(id)),
+        ...news.tags,
+      };
+      const oldTags = {
+        ...(yield* createInternalTags(id)),
+        ...olds.tags,
+      };
+      const { removed, upsert } = diffTags(oldTags, newTags);
+
+      if (upsert.length > 0) {
+        yield* sns.tagResource({
+          ResourceArn: output.topicArn,
+          Tags: upsert,
+        });
+      }
+
+      if (removed.length > 0) {
+        yield* sns.untagResource({
+          ResourceArn: output.topicArn,
+          TagKeys: removed,
+        });
+      }
+
+      if (
+        news.dataProtectionPolicy !== undefined &&
+        news.dataProtectionPolicy !== olds.dataProtectionPolicy
+      ) {
+        yield* sns.putDataProtectionPolicy({
+          ResourceArn: output.topicArn,
+          DataProtectionPolicy: news.dataProtectionPolicy,
+        });
+      }
+
+      yield* session.note(output.topicArn);
+
+      return {
+        ...output,
+        fifo: news.fifo ?? false,
+        attributes: newAttributes,
+        dataProtectionPolicy:
+          news.dataProtectionPolicy ?? output.dataProtectionPolicy,
+        tags: newTags,
+      };
+    }),
+    delete: Effect.fn(function* ({ output }) {
+      yield* sns
+        .deleteTopic({
+          TopicArn: output.topicArn,
+        })
+        .pipe(
+          Effect.catchTag("NotFoundException", () => Effect.void),
+          Effect.catchTag("InvalidParameterException", () => Effect.void),
+        );
+    }),
+  });
+
+const toTopicName = Effect.fn(function* (id: string, props: TopicProps) {
+  if (props.topicName) {
+    return props.topicName;
+  }
+
+  const baseName = yield* createPhysicalName({
+    id,
+    maxLength: props.fifo ? 256 - ".fifo".length : 256,
+  });
+
+  return props.fifo ? `${baseName}.fifo` : baseName;
+});
+
+const toAttributes = (props: TopicProps): Record<string, string> => ({
+  ...props.attributes,
+  ...(props.fifo ? { FifoTopic: "true" } : undefined),
+});
+
+const toTagMap = (tags: sns.Tag[] | undefined): Record<string, string> =>
+  Object.fromEntries(
+    (tags ?? [])
+      .filter(
+        (tag): tag is Required<Pick<sns.Tag, "Key" | "Value">> =>
+          typeof tag.Key === "string" && typeof tag.Value === "string",
+      )
+      .map((tag) => [tag.Key, tag.Value]),
+  );
+
+const toAttributeMap = (
+  attributes: Record<string, string | undefined> | undefined,
+): Record<string, string> =>
+  Object.fromEntries(
+    Object.entries(attributes ?? {}).filter(
+      (entry): entry is [string, string] => typeof entry[1] === "string",
+    ),
+  );
+
+const findTopicArnByName = Effect.fn(function* (topicName: string) {
+  let nextToken: string | undefined;
+
+  while (true) {
+    const response = yield* sns.listTopics({
+      NextToken: nextToken,
+    });
+
+    const match = response.Topics?.find(
+      (topic) => topic.TopicArn?.split(":").at(-1) === topicName,
+    )?.TopicArn;
+
+    if (match) {
+      return match;
+    }
+
+    if (!response.NextToken) {
+      return undefined;
+    }
+
+    nextToken = response.NextToken;
+  }
+});
+
+const readTopic = Effect.fn(function* ({
+  id,
+  topicArn,
+  topicName,
+}: {
+  id: string;
+  topicArn?: string;
+  topicName: string;
+}) {
+  const resolvedTopicArn = topicArn ?? (yield* findTopicArnByName(topicName));
+
+  if (!resolvedTopicArn) {
+    return undefined;
+  }
+
+  const topicState = yield* Effect.all(
+    [
+      sns.getTopicAttributes({
+        TopicArn: resolvedTopicArn,
+      }),
+      sns.listTagsForResource({
+        ResourceArn: resolvedTopicArn,
+      }),
+      sns
+        .getDataProtectionPolicy({
+          ResourceArn: resolvedTopicArn,
+        })
+        .pipe(
+          Effect.map((response) => response.DataProtectionPolicy),
+          Effect.catchTag("NotFoundException", () => Effect.succeed(undefined)),
+        ),
+    ],
+    { concurrency: "unbounded" },
+  ).pipe(
+    Effect.catchTag("NotFoundException", () => Effect.succeed(undefined)),
+    Effect.catchTag("InvalidParameterException", () =>
+      Effect.succeed(undefined),
+    ),
+  );
+
+  if (!topicState) {
+    return undefined;
+  }
+
+  const [attributes, tags, dataProtectionPolicy] = topicState;
+
+  const topicAttributes = toAttributeMap(attributes.Attributes);
+
+  return {
+    topicArn: resolvedTopicArn as TopicArn,
+    topicName: topicAttributes.TopicArn?.split(":").at(-1) ?? topicName,
+    fifo: topicAttributes.FifoTopic === "true",
+    attributes: topicAttributes,
+    dataProtectionPolicy,
+    tags: {
+      ...(yield* createInternalTags(id)),
+      ...toTagMap(tags.Tags),
+    },
+  };
+});

package/src/AWS/SNS/TopicEventSource.ts

@@ -0,0 +1,42 @@
+import type * as lambda from "aws-lambda";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as Binding from "../../Binding.ts";
+import type { Topic } from "./Topic.ts";
+
+export type TopicNotification = lambda.SNSMessage;
+
+export interface TopicEventSourceProps {
+  /**
+   * Raw SNS subscription attributes for the Lambda subscription, such as
+   * `FilterPolicy` or `RedrivePolicy`.
+   */
+  attributes?: Record<string, string>;
+}
+
+export class TopicEventSource extends Binding.Service<
+  TopicEventSource,
+  TopicEventSourceService
+>()("AWS.SNS.TopicEventSource") {}
+
+export type TopicEventSourceService = <StreamReq = never, Req = never>(
+  topic: Topic,
+  props: TopicEventSourceProps,
+  process: (
+    stream: Stream.Stream<TopicNotification, never, StreamReq>,
+  ) => Effect.Effect<void, never, Req>,
+) => Effect.Effect<void, never, never>;
+
+export const notifications = <T extends Topic>(
+  topic: T,
+  props: TopicEventSourceProps = {},
+) => ({
+  subscribe: <Req = never, StreamReq = never>(
+    process: (
+      stream: Stream.Stream<TopicNotification, never, StreamReq>,
+    ) => Effect.Effect<void, never, Req>,
+  ) =>
+    TopicEventSource.asEffect().pipe(
+      Effect.flatMap((source) => source(topic, props, process)),
+    ),
+});

package/src/AWS/SNS/TopicSink.ts

@@ -0,0 +1,61 @@
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Sink from "effect/Sink";
+import * as Binding from "../../Binding.ts";
+import { isFunction } from "../Lambda/Function.ts";
+import { PublishBatch } from "./PublishBatch.ts";
+import type { Topic } from "./Topic.ts";
+
+export class TopicSink extends Binding.Service<
+  TopicSink,
+  (
+    topic: Topic,
+  ) => Effect.Effect<Sink.Sink<void, string, readonly string[], never>>
+>()("AWS.SNS.TopicSink") {}
+
+export const TopicSinkLive = Layer.effect(
+  TopicSink,
+  Effect.gen(function* () {
+    const Policy = yield* TopicSinkPolicy;
+    const publishBatch = yield* PublishBatch;
+
+    return Effect.fn(function* (topic: Topic) {
+      yield* Policy(topic);
+      const publish = yield* publishBatch(topic);
+
+      return Sink.forEachArray((messages: readonly string[]) =>
+        publish({
+          PublishBatchRequestEntries: messages.map((message, index) => ({
+            Id: `${index}`,
+            Message: message,
+          })),
+        }).pipe(Effect.orDie, Effect.asVoid),
+      );
+    });
+  }),
+);
+
+export class TopicSinkPolicy extends Binding.Policy<
+  TopicSinkPolicy,
+  (topic: Topic) => Effect.Effect<void>
+>()("AWS.SNS.TopicSink") {}
+
+export const TopicSinkPolicyLive = TopicSinkPolicy.layer.succeed(
+  Effect.fn(function* (host, topic) {
+    if (isFunction(host)) {
+      yield* host.bind`Allow(${host}, AWS.SNS.TopicSink(${topic}))`({
+        policyStatements: [
+          {
+            Effect: "Allow",
+            Action: ["sns:Publish"],
+            Resource: [topic.topicArn],
+          },
+        ],
+      });
+    } else {
+      return yield* Effect.die(
+        `TopicSinkPolicy does not support runtime '${host.Type}'`,
+      );
+    }
+  }),
+);

package/src/AWS/SNS/UntagResource.ts

@@ -0,0 +1,66 @@
+import * as sns from "@distilled.cloud/aws/sns";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Binding from "../../Binding.ts";
+import { isFunction } from "../Lambda/Function.ts";
+import type { Topic } from "./Topic.ts";
+
+export interface UntagResourceRequest extends Omit<
+  sns.UntagResourceRequest,
+  "ResourceArn"
+> {}
+
+export class UntagResource extends Binding.Service<
+  UntagResource,
+  (
+    topic: Topic,
+  ) => Effect.Effect<
+    (
+      request: UntagResourceRequest,
+    ) => Effect.Effect<sns.UntagResourceResponse, sns.UntagResourceError>
+  >
+>()("AWS.SNS.UntagResource") {}
+
+export const UntagResourceLive = Layer.effect(
+  UntagResource,
+  Effect.gen(function* () {
+    const Policy = yield* UntagResourcePolicy;
+    const untagResource = yield* sns.untagResource;
+
+    return Effect.fn(function* (topic: Topic) {
+      const TopicArn = yield* topic.topicArn;
+      yield* Policy(topic);
+      return Effect.fn(function* (request: UntagResourceRequest) {
+        return yield* untagResource({
+          ...request,
+          ResourceArn: yield* TopicArn,
+        });
+      });
+    });
+  }),
+);
+
+export class UntagResourcePolicy extends Binding.Policy<
+  UntagResourcePolicy,
+  (topic: Topic) => Effect.Effect<void>
+>()("AWS.SNS.UntagResource") {}
+
+export const UntagResourcePolicyLive = UntagResourcePolicy.layer.succeed(
+  Effect.fn(function* (host, topic) {
+    if (isFunction(host)) {
+      yield* host.bind`Allow(${host}, AWS.SNS.UntagResource(${topic}))`({
+        policyStatements: [
+          {
+            Effect: "Allow",
+            Action: ["sns:UntagResource"],
+            Resource: [topic.topicArn],
+          },
+        ],
+      });
+    } else {
+      return yield* Effect.die(
+        `UntagResourcePolicy does not support runtime '${host.Type}'`,
+      );
+    }
+  }),
+);

package/src/AWS/SNS/index.ts

@@ -0,0 +1,21 @@
+export * from "./AddPermission.ts";
+export * from "./ConfirmSubscription.ts";
+export * from "./GetDataProtectionPolicy.ts";
+export * from "./GetSubscriptionAttributes.ts";
+export * from "./GetTopicAttributes.ts";
+export * from "./ListSubscriptions.ts";
+export * from "./ListSubscriptionsByTopic.ts";
+export * from "./ListTagsForResource.ts";
+export * from "./ListTopics.ts";
+export * from "./Publish.ts";
+export * from "./PublishBatch.ts";
+export * from "./PutDataProtectionPolicy.ts";
+export * from "./RemovePermission.ts";
+export * from "./SetSubscriptionAttributes.ts";
+export * from "./SetTopicAttributes.ts";
+export * from "./Subscription.ts";
+export * from "./TagResource.ts";
+export * from "./Topic.ts";
+export * from "./TopicEventSource.ts";
+export * from "./TopicSink.ts";
+export * from "./UntagResource.ts";

package/src/AWS/SQS/DeleteMessage.ts

@@ -0,0 +1,67 @@
+import * as sqs from "@distilled.cloud/aws/sqs";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Binding from "../../Binding.ts";
+import * as Output from "../../Output.ts";
+import { isFunction } from "../Lambda/Function.ts";
+import type { Queue } from "./Queue.ts";
+
+export interface DeleteMessageRequest extends Omit<
+  sqs.DeleteMessageRequest,
+  "QueueUrl"
+> {}
+
+export class DeleteMessage extends Binding.Service<
+  DeleteMessage,
+  (
+    queue: Queue,
+  ) => Effect.Effect<
+    (
+      request: DeleteMessageRequest,
+    ) => Effect.Effect<sqs.DeleteMessageResponse, sqs.DeleteMessageError>
+  >
+>()("AWS.SQS.DeleteMessage") {}
+
+export const DeleteMessageLive = Layer.effect(
+  DeleteMessage,
+  Effect.gen(function* () {
+    const Policy = yield* DeleteMessagePolicy;
+    const deleteMessage = yield* sqs.deleteMessage;
+
+    return Effect.fn(function* (queue: Queue) {
+      const QueueUrl = yield* queue.queueUrl;
+      yield* Policy(queue);
+      return Effect.fn(function* (request: DeleteMessageRequest) {
+        return yield* deleteMessage({
+          ...request,
+          QueueUrl: yield* QueueUrl,
+        });
+      });
+    });
+  }),
+);
+
+export class DeleteMessagePolicy extends Binding.Policy<
+  DeleteMessagePolicy,
+  (queue: Queue) => Effect.Effect<void>
+>()("AWS.SQS.DeleteMessage") {}
+
+export const DeleteMessagePolicyLive = DeleteMessagePolicy.layer.succeed(
+  Effect.fn(function* (host, queue) {
+    if (isFunction(host)) {
+      yield* host.bind`Allow(${host}, AWS.SQS.DeleteMessage(${queue}))`({
+        policyStatements: [
+          {
+            Effect: "Allow",
+            Action: ["sqs:DeleteMessage"],
+            Resource: [Output.interpolate`${queue.queueArn}`],
+          },
+        ],
+      });
+    } else {
+      return yield* Effect.die(
+        `DeleteMessagePolicy does not support runtime '${host.Type}'`,
+      );
+    }
+  }),
+);