alchemy-effect 0.0.0 → 0.1.0

package/src/aws/parse-ini.ts

@@ -0,0 +1,80 @@
+import type { ParsedIniData } from "@smithy/types";
+import { IniSectionType } from "@smithy/types";
+
+const CONFIG_PREFIX_SEPARATOR = ".";
+
+const prefixKeyRegex = /^([\w-]+)\s(["'])?([\w-@\+\.%:/]+)\2$/;
+const profileNameBlockList = ["__proto__", "profile __proto__"];
+
+export const parseIni = (iniData: string): ParsedIniData => {
+  const map: ParsedIniData = {};
+
+  let currentSection: string | undefined;
+  let currentSubSection: string | undefined;
+
+  for (const iniLine of iniData.split(/\r?\n/)) {
+    const trimmedLine = iniLine.split(/(^|\s)[;#]/)[0].trim(); // remove comments and trim
+    const isSection: boolean =
+      trimmedLine[0] === "[" && trimmedLine[trimmedLine.length - 1] === "]";
+    if (isSection) {
+      // New section found. Reset currentSection and currentSubSection.
+      currentSection = undefined;
+      currentSubSection = undefined;
+
+      const sectionName = trimmedLine.substring(1, trimmedLine.length - 1);
+      const matches = prefixKeyRegex.exec(sectionName);
+      if (matches) {
+        const [, prefix, , name] = matches;
+        // Add prefix, if the section name starts with `profile`, `sso-session` or `services`.
+        if (Object.values(IniSectionType).includes(prefix as IniSectionType)) {
+          currentSection = [prefix, name].join(CONFIG_PREFIX_SEPARATOR);
+        }
+      } else {
+        // If the section name does not match the regex, use the section name as is.
+        currentSection = sectionName;
+      }
+
+      if (profileNameBlockList.includes(sectionName)) {
+        throw new Error(`Found invalid profile name "${sectionName}"`);
+      }
+    } else if (currentSection) {
+      const indexOfEqualsSign = trimmedLine.indexOf("=");
+      if (![0, -1].includes(indexOfEqualsSign)) {
+        const [name, value]: [string, string] = [
+          trimmedLine.substring(0, indexOfEqualsSign).trim(),
+          trimmedLine.substring(indexOfEqualsSign + 1).trim(),
+        ];
+        if (value === "") {
+          currentSubSection = name;
+        } else {
+          if (currentSubSection && iniLine.trimStart() === iniLine) {
+            // Reset currentSubSection if there is no whitespace
+            currentSubSection = undefined;
+          }
+          map[currentSection] = map[currentSection] || {};
+          const key = currentSubSection
+            ? [currentSubSection, name].join(CONFIG_PREFIX_SEPARATOR)
+            : name;
+          map[currentSection][key] = value;
+        }
+      }
+    }
+  }
+
+  return map;
+};
+
+export const parseSSOSessionData = (data: ParsedIniData): ParsedIniData =>
+  Object.entries(data)
+    // filter out non sso-session keys
+    .filter(([key]) =>
+      key.startsWith(IniSectionType.SSO_SESSION + CONFIG_PREFIX_SEPARATOR),
+    )
+    // replace sso-session key with sso-session name
+    .reduce(
+      (acc, [key, value]) => ({
+        ...acc,
+        [key.substring(key.indexOf(CONFIG_PREFIX_SEPARATOR) + 1)]: value,
+      }),
+      {},
+    );

package/src/aws/profile.ts

@@ -0,0 +1,6 @@
+import * as Context from "effect/Context";
+
+export class AwsProfile extends Context.Tag("AWS::Profile")<
+  AwsProfile,
+  string
+>() {}

package/src/aws/region.ts

@@ -0,0 +1,35 @@
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+
+export class Region extends Context.Tag("AWS::Region")<Region, string>() {}
+
+export const of = (region: string) => Layer.succeed(Region, region);
+
+export const fromEnvOrElse = (region: string) =>
+  Layer.succeed(Region, process.env.AWS_REGION ?? region);
+
+export class EnvironmentVariableNotSet extends Data.TaggedError(
+  "EnvironmentVariableNotSet",
+)<{
+  message: string;
+  variable: string;
+}> {}
+
+export const fromEnv = () =>
+  Layer.effect(
+    Region,
+    Effect.gen(function* () {
+      const region = process.env.AWS_REGION;
+      if (!region) {
+        return yield* Effect.fail(
+          new EnvironmentVariableNotSet({
+            message: "AWS_REGION is not set",
+            variable: "AWS_REGION",
+          }),
+        );
+      }
+      return region;
+    }),
+  );

package/src/aws/s3.ts

@@ -0,0 +1,10 @@
+import * as Context from "effect/Context";
+import { S3 } from "itty-aws/s3";
+import { createAWSServiceClientLayer } from "./client.ts";
+
+export class S3Client extends Context.Tag("AWS::S3::Client")<S3Client, S3>() {}
+
+export const client = createAWSServiceClientLayer<typeof S3Client, S3>(
+  S3Client,
+  S3,
+);

package/src/aws/sqs/index.ts

@@ -0,0 +1,5 @@
+export * from "./queue.client.ts";
+export * from "./queue.consume.ts";
+export * from "./queue.provider.ts";
+export * from "./queue.send-message.ts";
+export * from "./queue.ts";

package/src/aws/sqs/queue.client.ts

@@ -0,0 +1,20 @@
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+
+import { SQS as SQSClient } from "itty-aws/sqs";
+import { createAWSServiceClientLayer } from "../client.ts";
+import * as Credentials from "../credentials.ts";
+import * as Region from "../region.ts";
+
+export class QueueClient extends Context.Tag("AWS::SQS::Queue.Client")<
+  QueueClient,
+  SQSClient
+>() {}
+
+export const client = createAWSServiceClientLayer<
+  typeof QueueClient,
+  SQSClient
+>(QueueClient, SQSClient);
+
+export const clientFromEnv = () =>
+  Layer.provide(client(), Layer.merge(Credentials.fromEnv(), Region.fromEnv()));

package/src/aws/sqs/queue.consume.ts

@@ -0,0 +1,46 @@
+import { Binding, type Capability, type From } from "alchemy-effect";
+import type * as lambda from "aws-lambda";
+import { Function } from "../lambda/index.ts";
+import { Queue } from "./queue.ts";
+
+export type QueueRecord<Data> = Omit<lambda.SQSRecord, "body"> & {
+  body: Data;
+};
+
+export type QueueEvent<Data> = Omit<lambda.SQSEvent, "Records"> & {
+  Records: QueueRecord<Data>[];
+};
+
+export interface Consume<Q = Queue> extends Capability<"AWS.SQS.Consume", Q> {}
+
+export interface QueueEventSourceProps {
+  batchSize?: number;
+  maxBatchingWindow?: number;
+  maxConcurrency?: number;
+  reportBatchItemFailures?: boolean;
+}
+
+export const QueueEventSource = Binding<
+  <Q extends Queue, const Props extends QueueEventSourceProps>(
+    queue: Q,
+    props?: Props,
+  ) => Binding<Function, Consume<From<Q>>, Props, "QueueEventSource">
+>(Function, "AWS.SQS.Consume", "QueueEventSource");
+
+export const consumeFromLambdaFunction = () =>
+  QueueEventSource.provider.succeed({
+    attach: ({ source: queue }) => ({
+      policyStatements: [
+        {
+          Sid: "AWS.SQS.Consume",
+          Effect: "Allow",
+          Action: [
+            "sqs:ReceiveMessage",
+            "sqs:DeleteMessage",
+            "sqs:ChangeMessageVisibility",
+          ],
+          Resource: [queue.attr.queueArn],
+        },
+      ],
+    }),
+  });

package/src/aws/sqs/queue.provider.ts

@@ -0,0 +1,94 @@
+import * as Effect from "effect/Effect";
+import * as Schedule from "effect/Schedule";
+
+import { App, type ProviderService } from "alchemy-effect";
+import { AccountID } from "../account.ts";
+import { Region } from "../region.ts";
+import { QueueClient } from "./queue.client.ts";
+import { Queue, type QueueProps } from "./queue.ts";
+
+export const queueProvider = () =>
+  Queue.provider.effect(
+    Effect.gen(function* () {
+      const sqs = yield* QueueClient;
+      const app = yield* App;
+      const region = yield* Region;
+      const accountId = yield* AccountID;
+      const createQueueName = (id: string, props: QueueProps) =>
+        props.queueName ??
+        `${app.name}-${id}-${app.stage}${props.fifo ? ".fifo" : ""}`;
+      const createAttributes = (props: QueueProps) => ({
+        FifoQueue: props.fifo ? "true" : "false",
+        FifoThroughputLimit: props.fifoThroughputLimit,
+        ContentBasedDeduplication: props.contentBasedDeduplication
+          ? "true"
+          : "false",
+        DeduplicationScope: props.deduplicationScope,
+        DelaySeconds: props.delaySeconds?.toString(),
+        MaximumMessageSize: props.maximumMessageSize?.toString(),
+        MessageRetentionPeriod: props.messageRetentionPeriod?.toString(),
+        ReceiveMessageWaitTimeSeconds:
+          props.receiveMessageWaitTimeSeconds?.toString(),
+        VisibilityTimeout: props.visibilityTimeout?.toString(),
+      });
+      return {
+        diff: Effect.fn(function* ({ id, news, olds }) {
+          const oldFifo = olds.fifo ?? false;
+          const newFifo = news.fifo ?? false;
+          if (oldFifo !== newFifo) {
+            return { action: "replace" } as const;
+          }
+          const oldQueueName = createQueueName(id, olds);
+          const newQueueName = createQueueName(id, news);
+          if (oldQueueName !== newQueueName) {
+            return { action: "replace" } as const;
+          }
+          return { action: "noop" } as const;
+        }),
+        create: Effect.fn(function* ({ id, news, session }) {
+          const queueName = createQueueName(id, news);
+          const response = yield* sqs
+            .createQueue({
+              QueueName: queueName,
+              Attributes: createAttributes(news),
+            })
+            .pipe(
+              Effect.retry({
+                while: (e) => e.name === "QueueDeletedRecently",
+                schedule: Schedule.fixed(1000).pipe(
+                  Schedule.tapOutput((i) =>
+                    session.note(
+                      `Queue was deleted recently, retrying... ${i + 1}s`,
+                    ),
+                  ),
+                ),
+              }),
+            );
+          const queueArn =
+            `arn:aws:sqs:${region}:${accountId}:${queueName}` as const;
+          const queueUrl = response.QueueUrl!;
+          yield* session.note(queueUrl);
+          return {
+            queueName,
+            queueUrl,
+            queueArn: queueArn,
+          };
+        }),
+        update: Effect.fn(function* ({ news, output, session }) {
+          yield* sqs.setQueueAttributes({
+            QueueUrl: output.queueUrl,
+            Attributes: createAttributes(news),
+          });
+          yield* session.note(output.queueUrl);
+          return output;
+        }),
+        delete: Effect.fn(function* (input) {
+          yield* sqs
+            .deleteQueue({
+              QueueUrl: input.output.queueUrl,
+            })
+            .pipe(Effect.catchTag("QueueDoesNotExist", () => Effect.void));
+        }),
+      } satisfies ProviderService<Queue>;
+    }),
+  );

package/src/aws/sqs/queue.send-message.ts

@@ -0,0 +1,51 @@
+import * as Effect from "effect/Effect";
+
+import {
+  Binding,
+  declare,
+  toEnvKey,
+  type Capability,
+  type To,
+} from "alchemy-effect";
+import { Function } from "../lambda/index.ts";
+import { QueueClient } from "./queue.client.ts";
+import { Queue } from "./queue.ts";
+
+export interface SendMessage<Q = Queue>
+  extends Capability<"AWS.SQS.SendMessage", Q> {}
+
+export const SendMessage = Binding<
+  <Q extends Queue>(queue: Q) => Binding<Function, SendMessage<To<Q>>>
+>(Function, "AWS.SQS.SendMessage");
+
+export const sendMessage = <Q extends Queue>(
+  queue: Q,
+  message: Q["props"]["schema"]["Type"],
+) =>
+  Effect.gen(function* () {
+    yield* declare<SendMessage<To<Q>>>();
+    const sqs = yield* QueueClient;
+    const url = process.env[toEnvKey(queue.id, "QUEUE_URL")]!;
+    return yield* sqs.sendMessage({
+      QueueUrl: url,
+      MessageBody: JSON.stringify(message),
+    });
+  });
+
+export const sendMessageFromLambdaFunction = () =>
+  SendMessage.provider.succeed({
+    attach: ({ source: queue }) => ({
+      env: {
+        // ask what attribute is needed to interact? e.g. is it the Queue ARN or the Queue URL?
+        [toEnvKey(queue.id, "QUEUE_URL")]: queue.attr.queueUrl,
+      },
+      policyStatements: [
+        {
+          Sid: "SendMessage",
+          Effect: "Allow",
+          Action: ["sqs:SendMessage"], // <- ask LLM how to generate this
+          Resource: [queue.attr.queueArn],
+        },
+      ],
+    }),
+  });

package/src/aws/sqs/queue.ts

@@ -0,0 +1,86 @@
+import type * as S from "effect/Schema";
+
+import { Resource } from "alchemy-effect";
+
+// required to avoid this error in consumers: "The inferred type of 'Messages' cannot be named without a reference to '../../effect-aws/node_modules/@types/aws-lambda'. This is likely not portable. A type annotation is necessary.ts(2742)"
+export type * as lambda from "aws-lambda";
+
+export const Queue = Resource<{
+  <const ID extends string, const Props extends QueueProps>(
+    id: ID,
+    props: Props,
+  ): Queue<ID, Props>;
+}>("AWS.SQS.Queue");
+
+export interface Queue<
+  ID extends string = string,
+  Props extends QueueProps = QueueProps,
+> extends Resource<"AWS.SQS.Queue", ID, Props, QueueAttrs<Props>> {}
+
+export type QueueAttrs<Props extends QueueProps> = {
+  queueName: Props["queueName"] extends string ? Props["queueName"] : string;
+  queueUrl: Props["fifo"] extends true ? `${string}.fifo` : string;
+  queueArn: `arn:aws:sqs:${string}:${string}:${Props["queueName"]}`;
+};
+
+export type QueueProps<Msg = any> = {
+  /**
+   * Schema for the message body.
+   */
+  schema: S.Schema<Msg>;
+  /**
+   * Name of the queue.
+   * @default ${app}-${stage}-${id}?.fifo
+   */
+  queueName?: string;
+  /**
+   * Delay in seconds for all messages in the queue (`0` - `900`).
+   * @default 0
+   */
+  delaySeconds?: number;
+  /**
+   * Maximum message size in bytes (`1,024` - `1,048,576`).
+   * @default 1048576
+   */
+  maximumMessageSize?: number;
+  /**
+   * Message retention period in seconds (`60` - `1,209,600`).
+   * @default 345600
+   */
+  messageRetentionPeriod?: number;
+  /**
+   * Time in seconds for `ReceiveMessage` to wait for a message (`0` - `20`).
+   * @default 0
+   */
+  receiveMessageWaitTimeSeconds?: number;
+  /**
+   * Visibility timeout in seconds (`0` - `43,200`).
+   * @default 30
+   */
+  visibilityTimeout?: number;
+} & (
+  | {
+      fifo?: false;
+      contentBasedDeduplication?: undefined;
+      deduplicationScope?: undefined;
+      fifoThroughputLimit?: undefined;
+    }
+  | {
+      fifo: true;
+      /**
+       * Enables content-based deduplication for FIFO queues. Only valid when `fifo` is `true`.
+       * @default false
+       */
+      contentBasedDeduplication?: boolean;
+      /**
+       * Specifies whether message deduplication occurs at the message group or queue level.
+       * Valid values are `messageGroup` and `queue`. Only valid when `fifo` is `true`.
+       */
+      deduplicationScope?: "messageGroup" | "queue";
+      /**
+       * Specifies whether the FIFO queue throughput quota applies to the entire queue or per message group.
+       * Valid values are `perQueue` and `perMessageGroupId`. Only valid when `fifo` is `true`.
+       */
+      fifoThroughputLimit?: "perQueue" | "perMessageGroupId";
+    }
+);

package/src/aws/sts.ts

@@ -0,0 +1,13 @@
+import * as Context from "effect/Context";
+import { STS } from "itty-aws/sts";
+import { createAWSServiceClientLayer } from "./client.ts";
+
+export class STSClient extends Context.Tag("AWS::STS::Client")<
+  STSClient,
+  STS
+>() {}
+
+export const client = createAWSServiceClientLayer<typeof STSClient, STS>(
+  STSClient,
+  STS,
+);

package/src/aws/zip.ts

@@ -0,0 +1,17 @@
+import * as Effect from "effect/Effect";
+
+export const zipCode = Effect.fn(function* (
+  content: string | Uint8Array<ArrayBufferLike>,
+) {
+  // Create a zip buffer in memory
+  const zip = new (yield* Effect.promise(() => import("jszip"))).default();
+  zip.file("index.mjs", content);
+
+  return yield* Effect.promise(() =>
+    zip.generateAsync({
+      type: "nodebuffer",
+      compression: "DEFLATE",
+      platform: "UNIX",
+    }),
+  );
+});

package/src/cli/approve.tsx

@@ -0,0 +1,30 @@
+// biome-ignore lint/correctness/noUnusedImports: UMD global
+import React from "react";
+
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+
+import * as Alchemy from "alchemy-effect";
+import { render } from "ink";
+
+import { ApprovePlan } from "./components/ApprovePlan.tsx";
+
+export const requireApproval = Layer.succeed(
+  Alchemy.PlanReviewer,
+  Alchemy.PlanReviewer.of({
+    approve: <P extends Alchemy.Plan>(plan: P) =>
+      Effect.gen(function* () {
+        let approved = false;
+
+        const { waitUntilExit } = render(
+          <ApprovePlan plan={plan} approve={(a) => (approved = a)} />,
+        );
+
+        yield* Effect.promise(() => waitUntilExit());
+
+        if (!approved) {
+          yield* Effect.fail(new Alchemy.PlanRejected());
+        }
+      }),
+  }),
+);

package/src/cli/clack.ts

@@ -0,0 +1,22 @@
+import * as Clack from "@clack/prompts";
+import * as Effect from "effect/Effect";
+
+const syncFn =
+  <F extends (...p: any[]) => any>(f: F) =>
+  (...p: Parameters<F>): Effect.Effect<ReturnType<F>> =>
+    Effect.sync(() => f(...p));
+
+const asyncFn =
+  <F extends (...p: any[]) => any>(f: F) =>
+  (...p: Parameters<F>): Effect.Effect<Awaited<ReturnType<F>>> =>
+    Effect.promise(() => f(...p));
+
+export const confirm = asyncFn(Clack.confirm);
+export const tasks = asyncFn(Clack.tasks);
+
+export const intro = syncFn(Clack.intro);
+export const outro = syncFn(Clack.outro);
+export const note = syncFn(Clack.note);
+export const spinner = syncFn(Clack.spinner);
+
+export const isCancel = Clack.isCancel;

package/src/cli/components/ApprovePlan.tsx

@@ -0,0 +1,44 @@
+// biome-ignore lint/style/useImportType: UMD global
+import React, { useState } from "react";
+
+import type * as Alchemy from "alchemy-effect";
+import { Box, Text, useApp, useInput } from "ink";
+
+import { Plan } from "./Plan.tsx";
+
+export interface ApprovePlanProps {
+  plan: Alchemy.Plan;
+  approve: (result: boolean) => void;
+}
+
+export function ApprovePlan(props: ApprovePlanProps): React.JSX.Element {
+  const { plan, approve } = props;
+  const [selected, setSelected] = useState(0);
+  const { exit } = useApp();
+
+  useInput((_input, key) => {
+    if (key.leftArrow || key.rightArrow) {
+      setSelected((prev) => (prev === 0 ? 1 : 0));
+    } else if (key.return) {
+      approve(selected === 0);
+      exit();
+    }
+  });
+
+  return (
+    <Box flexDirection="column">
+      <Plan plan={plan} />
+      <Box marginTop={1}>
+        <Text>Proceed?</Text>
+      </Box>
+      <Box gap={1}>
+        <Text color={selected === 0 ? "green" : "gray"}>
+          {selected === 0 ? "◉" : "○"} Yes
+        </Text>
+        <Text color={selected === 1 ? "red" : "gray"}>
+          {selected === 1 ? "◉" : "○"} No
+        </Text>
+      </Box>
+    </Box>
+  );
+}