alchemy-effect 0.2.0 → 0.4.0

package/src/aws/sqs/index.ts

@@ -4,3 +4,5 @@ export * from "./queue.event-source.ts";
 export * from "./queue.provider.ts";
 export * from "./queue.send-message.ts";
 export * from "./queue.ts";
+
+import "../config.ts";

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

@@ -1,5 +1,5 @@
-import { type Capability } from "alchemy-effect";
 import type * as lambda from "aws-lambda";
+import type { Capability } from "../../capability.ts";
 import { Queue } from "./queue.ts";
 
 export type QueueRecord<Data> = Omit<lambda.SQSRecord, "body"> & {

package/src/aws/sqs/queue.event-source.ts

@@ -1,17 +1,15 @@
-import { Binding, type From } from "alchemy-effect";
 import * as Effect from "effect/Effect";
 import * as Schedule from "effect/Schedule";
 import type * as Lambda from "itty-aws/lambda";
+import { Binding } from "../../binding.ts";
+import type { From } from "../../policy.ts";
 import { createTagger, hasTags } from "../../tags.ts";
-import { Account } from "../account.ts";
-import {
-  Function,
-  LambdaClient,
-  type FunctionBinding,
-} from "../lambda/index.ts";
-import { Region } from "../region.ts";
 import type { Consume } from "./queue.consume.ts";
 import { Queue, type QueueAttrs, type QueueProps } from "./queue.ts";
+import { Function, type FunctionBinding } from "../lambda/function.ts";
+import { LambdaClient } from "../lambda/client.ts";
+import { Account } from "../account.ts";
+import { Region } from "../region.ts";
 
 export interface QueueEventSourceProps {
   batchSize?: number;
@@ -43,10 +41,9 @@ export const QueueEventSource = Binding<
 
 export const queueEventSourceProvider = () =>
   QueueEventSource.provider.effect(
-    // @ts-expect-error
     Effect.gen(function* () {
-      const region = yield* Region;
       const accountId = yield* Account;
+      const region = yield* Region;
       const lambda = yield* LambdaClient;
       const tagged = yield* createTagger();
 
@@ -113,45 +110,26 @@ export const queueEventSourceProvider = () =>
           return undefined;
         });
 
-      const createFunctionBinding = (queue: {
-        attr: { queueArn: string };
-      }) => ({
-        // we need the policies to be present before the event source mapping is created
-        policyStatements: [
-          {
-            Sid: "AWS.SQS.Consume",
-            Effect: "Allow" as const,
-            Action: [
-              "sqs:ReceiveMessage",
-              "sqs:DeleteMessage",
-              "sqs:ChangeMessageVisibility",
-            ],
-            Resource: [queue.attr.queueArn],
-          },
-        ],
-      });
-
       return {
-        attach: ({ source: queue }) => {
-          console.log("attaching queue event source", queue.id);
-          return {
-            // we need the policies to be present before the event source mapping is created
-            policyStatements: [
-              {
-                Sid: "AWS.SQS.Consume",
-                Effect: "Allow" as const,
-                Action: [
-                  "sqs:ReceiveMessage",
-                  "sqs:DeleteMessage",
-                  "sqs:ChangeMessageVisibility",
-                  "sqs:GetQueueAttributes",
-                  "sqs:GetQueueUrl",
-                ],
-                Resource: [queue.attr.queueArn],
-              },
-            ],
-          };
-        },
+        attach: ({ source: queue, attr }) => ({
+          // TODO(sam): bit of a broken model here - we can't know the UUID until post-attach
+          uuid: attr?.uuid ?? undefined!,
+          // we need the policies to be present before the event source mapping is created
+          policyStatements: [
+            {
+              Sid: "AWS.SQS.Consume",
+              Effect: "Allow" as const,
+              Action: [
+                "sqs:ReceiveMessage",
+                "sqs:DeleteMessage",
+                "sqs:ChangeMessageVisibility",
+                "sqs:GetQueueAttributes",
+                "sqs:GetQueueUrl",
+              ],
+              Resource: [queue.attr.queueArn],
+            },
+          ],
+        }),
         postattach: Effect.fn(function* ({
           source: queue,
           props: { batchSize, maxBatchingWindow, scalingConfig } = {},
@@ -160,11 +138,6 @@ export const queueEventSourceProvider = () =>
             attr: { functionName },
           },
         }) {
-          console.log(
-            "postattaching queue event source",
-            queue.id,
-            functionName,
-          );
           const config:
             | Lambda.CreateEventSourceMappingRequest
             | Lambda.UpdateEventSourceMappingRequest = {
@@ -220,10 +193,11 @@ export const queueEventSourceProvider = () =>
                 ),
               schedule: Schedule.exponential(100),
             }),
+            Effect.orDie,
           );
           return {
             ...attr,
-            uuid: eventSourceMapping.UUID,
+            uuid: eventSourceMapping.UUID!,
           };
         }),
         detach: Effect.fn(function* ({
@@ -235,7 +209,7 @@ export const queueEventSourceProvider = () =>
         }) {
           const uuid =
             attr?.uuid ??
-            (yield* findEventSourceMapping(queue, functionName))?.UUID!;
+            (yield* findEventSourceMapping(queue, functionName))?.UUID;
           if (uuid) {
             // we found (or were aware of) the event source mapping, so we can delete it
             yield* (

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

@@ -1,7 +1,8 @@
 import * as Effect from "effect/Effect";
 import * as Schedule from "effect/Schedule";
 
-import { App, type ProviderService } from "alchemy-effect";
+import { App } from "../../app.ts";
+import type { ProviderService } from "../../provider.ts";
 import { Account } from "../account.ts";
 import { Region } from "../region.ts";
 import { SQSClient } from "./client.ts";
@@ -14,7 +15,13 @@ export const queueProvider = () =>
       const app = yield* App;
       const region = yield* Region;
       const accountId = yield* Account;
-      const createQueueName = (id: string, props: QueueProps) =>
+      const createQueueName = (
+        id: string,
+        props: {
+          queueName?: string | undefined;
+          fifo?: boolean;
+        },
+      ) =>
         props.queueName ??
         `${app.name}-${id}-${app.stage}${props.fifo ? ".fifo" : ""}`;
       const createAttributes = (props: QueueProps) => ({
@@ -32,6 +39,7 @@ export const queueProvider = () =>
         VisibilityTimeout: props.visibilityTimeout?.toString(),
       });
       return {
+        stables: ["queueName", "queueUrl", "queueArn"],
         diff: Effect.fn(function* ({ id, news, olds }) {
           const oldFifo = olds.fifo ?? false;
           const newFifo = news.fifo ?? false;

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

@@ -1,13 +1,10 @@
 import * as Effect from "effect/Effect";
 
-import {
-  Binding,
-  declare,
-  toEnvKey,
-  type Capability,
-  type To,
-} from "alchemy-effect";
-import { Function } from "../lambda/index.ts";
+import { Binding } from "../../binding.ts";
+import type { Capability } from "../../capability.ts";
+import { toEnvKey } from "../../env.ts";
+import { declare, type To } from "../../policy.ts";
+import { Function } from "../lambda/function.ts";
 import { SQSClient } from "./client.ts";
 import { Queue } from "./queue.ts";
 

package/src/aws/sqs/queue.ts

@@ -1,7 +1,6 @@
 import type * as S from "effect/Schema";
-
-import { Resource } from "alchemy-effect";
-
+import type { Input } from "../../input.ts";
+import { Resource } from "../../resource.ts";
 // 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";
 
@@ -15,7 +14,13 @@ export const Queue = Resource<{
 export interface Queue<
   ID extends string = string,
   Props extends QueueProps = QueueProps,
-> extends Resource<"AWS.SQS.Queue", ID, Props, QueueAttrs<Props>> {}
+> extends Resource<
+    "AWS.SQS.Queue",
+    ID,
+    Props,
+    QueueAttrs<Extract<Input.Resolve<Props>, QueueProps>>,
+    Queue
+  > {}
 
 export type QueueAttrs<Props extends QueueProps> = {
   queueName: Props["queueName"] extends string ? Props["queueName"] : string;

package/src/binding.ts

@@ -2,9 +2,9 @@ import * as Context from "effect/Context";
 import type { Effect } from "effect/Effect";
 import * as Layer from "effect/Layer";
 import type { Capability, ICapability } from "./capability.ts";
-import type { Diff } from "./provider.ts";
-import type { Resource } from "./resource.ts";
-import type { Runtime } from "./runtime.ts";
+import type { Diff } from "./diff.ts";
+import type { IResource, Resource } from "./resource.ts";
+import type { IRuntime } from "./runtime.ts";
 
 export interface BindingProps {
   [key: string]: any;
@@ -13,7 +13,7 @@ export interface BindingProps {
 export const isBinding = (b: any): b is AnyBinding =>
   "runtime" in b && "capability" in b && "tag" in b && "output" in b;
 
-export type AnyBinding<F extends Runtime = any> = Binding<
+export type AnyBinding<F extends IRuntime = any> = Binding<
   F,
   any,
   any,
@@ -23,7 +23,7 @@ export type AnyBinding<F extends Runtime = any> = Binding<
 >;
 
 export interface Binding<
-  Run extends Runtime<any, any, any>,
+  Run extends IRuntime<any, any, any>,
   Cap extends Capability = Capability,
   Props = any,
   Attr extends Run["binding"] = any,
@@ -40,14 +40,14 @@ export interface Binding<
 
 /** Tag for a Service that can bind a Capability to a Runtime */
 export interface Bind<
-  F extends Runtime,
+  F extends IRuntime,
   Cap extends Capability,
   Tag extends string,
 > extends Context.Tag<
     `${F["type"]}(${Cap["type"]}, ${Tag})`,
     BindingService<
       F,
-      Extract<Extract<Cap["resource"], Resource>["parent"], Resource>,
+      Extract<Extract<Cap["resource"], Resource>["base"], Resource>,
       F["props"]
     >
   > {
@@ -91,12 +91,12 @@ export const Binding: {
         effect: (eff) => Layer.effect(Tag, eff),
         succeed: (service) => Layer.succeed(Tag, service),
       },
-    } satisfies BindingDeclaration<Runtime, any>,
+    } satisfies BindingDeclaration<IRuntime, any>,
   );
 };
 
 export interface BindingDeclaration<
-  Run extends Runtime,
+  Run extends IRuntime,
   F extends (target: any, props?: any) => AnyBinding<Run>,
   Tag extends string = ReturnType<F>["tag"],
   Cap extends Capability = ReturnType<F>["capability"],
@@ -126,8 +126,8 @@ export interface BindingDeclaration<
 }
 
 export interface BindingDiffProps<
-  Source extends Resource = Resource,
-  Target extends Resource = Resource,
+  Source extends IResource = IResource,
+  Target extends IResource = IResource,
   Props = any,
   Attr = any,
 > {
@@ -148,8 +148,8 @@ export interface BindingDiffProps<
 }
 
 export interface BindingAttachProps<
-  Source extends Resource,
-  Target extends Resource,
+  Source extends IResource,
+  Target extends IResource,
   Props,
   Attr,
 > {
@@ -168,8 +168,8 @@ export interface BindingAttachProps<
 }
 
 export interface BindingReattachProps<
-  Source extends Resource,
-  Target extends Resource,
+  Source extends IResource,
+  Target extends IResource,
   Props,
   Attr,
 > {
@@ -188,8 +188,8 @@ export interface BindingReattachProps<
 }
 
 export interface BindingDetachProps<
-  Source extends Resource,
-  Target extends Resource,
+  Source extends IResource,
+  Target extends IResource,
   Props,
   Attr,
 > {
@@ -208,8 +208,8 @@ export interface BindingDetachProps<
 }
 
 export type BindingService<
-  Target extends Runtime = any,
-  Source extends Resource = Resource,
+  Target extends IRuntime = any,
+  Source extends IResource = IResource,
   Props = any,
   Attr extends Target["binding"] = any,
   DiffReq = never,

package/src/cli/components/ApprovePlan.tsx

@@ -1,13 +1,13 @@
 // 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 type { IPlan as AlchemyPlan } from "../../plan.ts";
 
 import { Plan } from "./Plan.tsx";
 
 export interface ApprovePlanProps {
-  plan: Alchemy.Plan;
+  plan: AlchemyPlan;
   approve: (result: boolean) => void;
 }
 

package/src/cli/components/Plan.tsx

@@ -1,11 +1,12 @@
 // biome-ignore lint/style/useImportType: UMD global
 import React, { useMemo } from "react";
 
-import type { BindNode, Capability, CRUD, Plan } from "alchemy-effect";
 import { Box, Text } from "ink";
+import type { Capability } from "../../capability.ts";
+import type { IPlan as AlchemyPlan, BindNode, CRUD } from "../../plan.ts";
 
 export interface PlanProps {
-  plan: Plan;
+  plan: AlchemyPlan;
 }
 export function Plan({ plan }: PlanProps): React.JSX.Element {
   const items = useMemo(

package/src/cli/components/PlanProgress.tsx

@@ -1,20 +1,27 @@
 // biome-ignore lint/style/useImportType: UMD global
 import React, { useEffect, useMemo, useRef, useState } from "react";
 
-import type * as Alchemy from "alchemy-effect";
 import { Box, Text } from "ink";
-import type { ProgressEventSource } from "../progress.tsx";
-import { useGlobalSpinner } from "../spinner.ts";
+import type {
+  ApplyEvent,
+  ApplyStatus,
+  StatusChangeEvent,
+} from "../../event.ts";
+import type { IPlan } from "../../plan.ts";
+
+interface ProgressEventSource {
+  subscribe(listener: (event: ApplyEvent) => void): () => void;
+}
 
 interface PlanTask
-  extends Required<Pick<Alchemy.StatusChangeEvent, "id" | "type" | "status">> {
+  extends Required<Pick<StatusChangeEvent, "id" | "type" | "status">> {
   message?: string;
   updatedAt: number;
 }
 
-export interface PlanProgressProps {
+interface PlanProgressProps {
   source: ProgressEventSource;
-  plan: Alchemy.Plan;
+  plan: IPlan;
 }
 
 export function PlanProgress(props: PlanProgressProps): React.JSX.Element {
@@ -29,7 +36,7 @@ export function PlanProgress(props: PlanProgressProps): React.JSX.Element {
     ];
     for (const [id, item] of nodes) {
       const planItem = item!;
-      const status: Alchemy.ApplyStatus =
+      const status: ApplyStatus =
         planItem.action === "noop" ? "success" : "pending";
       initialTasks.set(id, {
         id,
@@ -89,7 +96,7 @@ export function PlanProgress(props: PlanProgressProps): React.JSX.Element {
       ];
       for (const [id, item] of nodes) {
         const planItem = item!;
-        const status: Alchemy.ApplyStatus =
+        const status: ApplyStatus =
           planItem.action === "noop" ? "success" : "pending";
         initialTasks.set(id, {
           id,
@@ -146,7 +153,7 @@ export function PlanProgress(props: PlanProgressProps): React.JSX.Element {
   );
 }
 
-function statusPriority(status: Alchemy.ApplyStatus): number {
+function statusPriority(status: ApplyStatus): number {
   switch (status) {
     case "success":
     case "created":
@@ -166,9 +173,7 @@ function statusPriority(status: Alchemy.ApplyStatus): number {
   }
 }
 
-function statusColor(
-  status: Alchemy.ApplyStatus,
-): Parameters<typeof Text>[0]["color"] {
+function statusColor(status: ApplyStatus): Parameters<typeof Text>[0]["color"] {
   switch (status) {
     case "pending":
       return "gray";
@@ -190,13 +195,13 @@ function statusColor(
   }
 }
 
-function statusIcon(status: Alchemy.ApplyStatus, spinnerChar: string): string {
+function statusIcon(status: ApplyStatus, spinnerChar: string): string {
   if (isInProgress(status)) return spinnerChar;
   if (status === "fail") return "✗";
   return "✓"; // created/updated/deleted/success
 }
 
-function isInProgress(status: Alchemy.ApplyStatus): boolean {
+function isInProgress(status: ApplyStatus): boolean {
   return (
     status === "pending" ||
     status === "creating" ||
@@ -204,3 +209,16 @@ function isInProgress(status: Alchemy.ApplyStatus): boolean {
     status === "deleting"
   );
 }
+
+const spinnerFrames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+function useGlobalSpinner(intervalMs = 80): string {
+  const [index, setIndex] = useState(0);
+  useEffect(() => {
+    const timer = setInterval(() => {
+      setIndex((i) => (i + 1) % spinnerFrames.length);
+    }, intervalMs);
+    return () => clearInterval(timer);
+  }, [intervalMs]);
+  return spinnerFrames[index];
+}

package/src/cli/index.ts

@@ -1,6 +1,2 @@
-import * as Layer from "effect/Layer";
-
-import { requireApproval } from "./approve.tsx";
-import { reportProgress } from "./progress.tsx";
-
-export const layer = Layer.merge(requireApproval, reportProgress);
+export * from "./service.ts";
+export * from "./ink-service.tsx";

package/src/cli/ink-service.tsx

@@ -0,0 +1,61 @@
+import React from "react";
+
+import { type PlanStatusSession, CLI } from "./service.ts";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import type { IPlan } from "../plan.ts";
+import { render } from "ink";
+import { ApprovePlan } from "./components/ApprovePlan.tsx";
+import { Plan } from "./components/Plan.tsx";
+import { PlanProgress } from "./components/PlanProgress.tsx";
+import type { ApplyEvent } from "../event.ts";
+
+export const inkCLI = () =>
+  Layer.succeed(
+    CLI,
+    CLI.of({
+      approvePlan,
+      displayPlan,
+      startApplySession,
+    }),
+  );
+
+const approvePlan = Effect.fn(function* <P extends IPlan>(plan: P) {
+  let approved = false;
+  const { waitUntilExit } = render(
+    <ApprovePlan plan={plan} approve={(a) => (approved = a)} />,
+  );
+  yield* Effect.promise(waitUntilExit);
+  return approved;
+});
+
+const displayPlan = <P extends IPlan>(plan: P): Effect.Effect<void> =>
+  Effect.sync(() => {
+    const { unmount } = render(<Plan plan={plan} />);
+    unmount();
+  });
+
+const startApplySession = Effect.fn(function* <P extends IPlan>(plan: P) {
+  const listeners = new Set<(event: ApplyEvent) => void>();
+  const { unmount } = render(
+    <PlanProgress
+      plan={plan}
+      source={{
+        subscribe(listener) {
+          listeners.add(listener);
+          return () => listeners.delete(listener);
+        },
+      }}
+    />,
+  );
+  return {
+    done: Effect.fn(function* () {
+      yield* Effect.sleep(10); // give the react event loop time to re-render
+      yield* Effect.sync(() => unmount());
+    }),
+    emit: (event) =>
+      Effect.sync(() => {
+        for (const listener of listeners) listener(event);
+      }),
+  } satisfies PlanStatusSession;
+});

package/src/cli/service.ts

@@ -0,0 +1,23 @@
+import type { IPlan } from "../plan.ts";
+import * as Effect from "effect/Effect";
+import * as Context from "effect/Context";
+import type { ApplyEvent } from "../event.ts";
+
+export interface PlanStatusSession {
+  emit: (event: ApplyEvent) => Effect.Effect<void>;
+  done: () => Effect.Effect<void>;
+}
+
+export interface ScopedPlanStatusSession extends PlanStatusSession {
+  note: (note: string) => Effect.Effect<void>;
+}
+
+export interface CLIService {
+  approvePlan: <P extends IPlan>(plan: P) => Effect.Effect<boolean>;
+  displayPlan: <P extends IPlan>(plan: P) => Effect.Effect<void>;
+  startApplySession: <P extends IPlan>(
+    plan: P,
+  ) => Effect.Effect<PlanStatusSession>;
+}
+
+export class CLI extends Context.Tag("CLIService")<CLI, CLIService>() {}

package/src/cloudflare/account.ts

@@ -0,0 +1,37 @@
+import * as Layer from "effect/Layer";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Config from "effect/Config";
+import { App } from "../app.ts";
+
+export class Account extends Context.Tag("cloudflare/account-id")<
+  Account,
+  string
+>() {}
+
+export const fromEnv = () =>
+  Layer.effect(
+    Account,
+    Effect.gen(function* () {
+      const accountId = yield* Config.string("CLOUDFLARE_ACCOUNT_ID");
+      if (!accountId) {
+        return yield* Effect.die("CLOUDFLARE_ACCOUNT_ID is not set");
+      }
+      return accountId;
+    }),
+  );
+
+export const fromStageConfig = () =>
+  Layer.effect(
+    Account,
+    Effect.gen(function* () {
+      const app = yield* App;
+      const accountId =
+        app.config.cloudflare?.account ??
+        (yield* Config.string("CLOUDFLARE_ACCOUNT_ID"));
+      if (!accountId) {
+        return yield* Effect.die("CLOUDFLARE_ACCOUNT_ID is not set");
+      }
+      return accountId;
+    }),
+  );