alchemy-effect 0.5.0 → 0.6.2

package/src/aws/index.ts

@@ -1,63 +0,0 @@
-import * as Layer from "effect/Layer";
-
-// oxlint-disable-next-line no-unused-vars - needed or else provider types are transitively resolved through DynamoDB.Provider<..> lol
-
-import * as ESBuild from "../esbuild.ts";
-import * as Account from "./account.ts";
-import * as Credentials from "./credentials.ts";
-import * as DynamoDB from "./dynamodb/index.ts";
-import * as EC2 from "./ec2/index.ts";
-import * as IAM from "./iam.ts";
-import * as Lambda from "./lambda/index.ts";
-import * as Region from "./region.ts";
-import * as S3 from "./s3.ts";
-import * as SQS from "./sqs/index.ts";
-import * as STS from "./sts.ts";
-
-export { loadProfile, loadSSOCredentials } from "./credentials.ts";
-
-import "./config.ts";
-
-export const resources = () =>
-  Layer.mergeAll(
-    DynamoDB.tableProvider(),
-    EC2.internetGatewayProvider(),
-    EC2.routeProvider(),
-    EC2.routeTableAssociationProvider(),
-    EC2.routeTableProvider(),
-    EC2.subnetProvider(),
-    EC2.vpcProvider(),
-    Lambda.functionProvider(),
-    SQS.queueProvider(),
-  );
-
-export const bindings = () =>
-  Layer.mergeAll(
-    DynamoDB.getItemFromLambdaFunction(),
-    SQS.queueEventSourceProvider(),
-    SQS.sendMessageFromLambdaFunction(),
-  );
-
-export const clients = () =>
-  Layer.mergeAll(
-    DynamoDB.client(),
-    EC2.client(),
-    IAM.client(),
-    Lambda.client(),
-    S3.client(),
-    SQS.client(),
-    // STS.client(),
-  );
-
-export const utils = () => Layer.mergeAll(ESBuild.layer());
-
-export const providers = () =>
-  resources().pipe(
-    Layer.provideMerge(bindings()),
-    Layer.provideMerge(clients()),
-    Layer.provideMerge(utils()),
-    Layer.provideMerge(Account.fromStageConfig()),
-    Layer.provideMerge(STS.client()),
-    Layer.provideMerge(Region.fromStageConfig()),
-    Layer.provideMerge(Credentials.fromStageConfig()),
-  );

package/src/aws/lambda/client.ts

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

package/src/aws/lambda/consume.ts

@@ -1,64 +0,0 @@
-import type {
-  Context as LambdaContext,
-  SQSBatchResponse,
-  SQSEvent,
-} from "aws-lambda";
-import * as Effect from "effect/Effect";
-import * as S from "effect/Schema";
-import { declare, type From } from "../../policy.ts";
-import * as Lambda from "./function.ts";
-import type { Queue } from "../sqs/queue.ts";
-import type { Consume, QueueEvent } from "../sqs/queue.consume.ts";
-import { QueueEventSource } from "../sqs/queue.event-source.ts";
-
-export const consume =
-  <Q extends Queue, ID extends string, Req>(
-    id: ID,
-    {
-      queue,
-      handle,
-    }: {
-      queue: Q;
-      handle: (
-        event: QueueEvent<Q["props"]["schema"]["Type"]>,
-        context: LambdaContext,
-      ) => Effect.Effect<SQSBatchResponse | void, never, Req>;
-    },
-  ) =>
-  <const Props extends Lambda.FunctionProps<Req>>({
-    bindings,
-    ...props
-  }: Props) =>
-    Lambda.Function(id, {
-      handle: Effect.fn(function* (event: SQSEvent, context: LambdaContext) {
-        yield* declare<Consume<From<Q>>>();
-        const records = yield* Effect.all(
-          event.Records.map(
-            Effect.fn(function* (record) {
-              return {
-                ...record,
-                body: yield* S.validate(queue.props.schema)(record.body).pipe(
-                  Effect.catchAll(() => Effect.void),
-                ),
-              };
-            }),
-          ),
-        );
-        const response = yield* handle(
-          {
-            Records: records.filter((record) => record.body !== undefined),
-          },
-          context,
-        );
-        return {
-          batchItemFailures: [
-            ...(response?.batchItemFailures ?? []),
-            ...records
-              .filter((record) => record.body === undefined)
-              .map((failed) => ({
-                itemIdentifier: failed.messageId,
-              })),
-          ],
-        } satisfies SQSBatchResponse;
-      }),
-    })({ ...props, bindings: bindings.and(QueueEventSource(queue)) });

package/src/aws/lambda/function.handler.ts

@@ -1,30 +0,0 @@
-import type { Context as LambdaContext } from "aws-lambda";
-import * as Effect from "effect/Effect";
-import type { Capability } from "../../capability.ts";
-
-type Handler = (
-  event: any,
-  context: LambdaContext,
-) => Effect.Effect<any, any, never>;
-
-type HandlerEffect<Req = Capability> = Effect.Effect<Handler, any, Req>;
-
-const memo = Symbol.for("alchemy::memo");
-
-// TODO(sam): is there a better way to lazily evaluate the Effect and cache the result?
-const resolveHandler = async (
-  effect: HandlerEffect & {
-    [memo]?: Handler;
-  },
-) =>
-  (effect[memo] ??= await Effect.runPromise(
-    // safe to cast away the Capability requirements since they are phantoms
-    effect as HandlerEffect<never>,
-  ));
-
-export const toHandler =
-  <H extends Handler>(effect: Effect.Effect<H, any, Capability>) =>
-  async (event: any, context: LambdaContext) =>
-    Effect.runPromise(
-      (await resolveHandler(effect))(event, context),
-    ) as Promise<Effect.Effect.Success<ReturnType<H>>>;

package/src/aws/lambda/function.invoke.ts

@@ -1,44 +0,0 @@
-import * as Effect from "effect/Effect";
-
-import { Binding } from "../../binding.ts";
-import type { Capability } from "../../capability.ts";
-import { toEnvKey } from "../../env.ts";
-import { declare, type On } from "../../policy.ts";
-import type { $ } from "../../$.ts";
-import { LambdaClient } from "./client.ts";
-import { Function } from "./function.ts";
-
-export interface InvokeFunction<Resource = unknown>
-  extends Capability<"AWS.Lambda.InvokeFunction", Resource> {}
-
-export const InvokeFunction = Binding<
-  <F extends Function>(func: F) => Binding<Function, InvokeFunction<On<F>>>
->(Function, "AWS.Lambda.InvokeFunction");
-
-export const invoke = <F extends Function>(func: F, input: any) =>
-  Effect.gen(function* () {
-    const lambda = yield* LambdaClient;
-    const functionArn = process.env[`${func.id}-functionArn`]!;
-    yield* declare<InvokeFunction<F>>();
-    return yield* lambda.invoke({
-      FunctionName: functionArn,
-      InvocationType: "RequestResponse",
-      Payload: JSON.stringify(input),
-    });
-  });
-
-export const invokeFunctionFromLambda = InvokeFunction.provider.succeed({
-  attach: ({ source: func }) => ({
-    env: {
-      [toEnvKey(func.id, "FUNCTION_ARN")]: func.attr.functionArn,
-    },
-    policyStatements: [
-      {
-        Sid: "AWS.Lambda.InvokeFunction",
-        Effect: "Allow",
-        Action: ["lambda:InvokeFunction"],
-        Resource: [func.attr.functionArn],
-      },
-    ],
-  }),
-});