alchemy-effect 0.0.0 → 0.2.0

package/src/cli/components/PlanProgress.tsx

@@ -0,0 +1,206 @@
+// 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";
+
+interface PlanTask
+  extends Required<Pick<Alchemy.StatusChangeEvent, "id" | "type" | "status">> {
+  message?: string;
+  updatedAt: number;
+}
+
+export interface PlanProgressProps {
+  source: ProgressEventSource;
+  plan: Alchemy.Plan;
+}
+
+export function PlanProgress(props: PlanProgressProps): React.JSX.Element {
+  const { source, plan } = props;
+  const spinner = useGlobalSpinner();
+  const [tasks, setTasks] = useState<Map<string, PlanTask>>(() => {
+    // Initialize tasks from the plan with appropriate starting status
+    const initialTasks = new Map<string, PlanTask>();
+    const nodes = [
+      ...Object.entries(plan.resources),
+      ...Object.entries(plan.deletions),
+    ];
+    for (const [id, item] of nodes) {
+      const planItem = item!;
+      const status: Alchemy.ApplyStatus =
+        planItem.action === "noop" ? "success" : "pending";
+      initialTasks.set(id, {
+        id,
+        type: planItem.resource.type,
+        status,
+        updatedAt: Date.now(),
+      });
+    }
+    return initialTasks;
+  });
+
+  const unsubscribeRef = useRef<null | (() => void)>(null);
+
+  useEffect(() => {
+    unsubscribeRef.current?.();
+    unsubscribeRef.current = source.subscribe((event) => {
+      setTasks((prev) => {
+        const next = new Map(prev);
+        const current = next.get(event.id);
+
+        if (event.kind === "status-change") {
+          if (!event.bindingId) {
+            // Only handle resource-level events, ignore binding events
+            const updated: PlanTask = {
+              id: event.id,
+              type: event.type,
+              status: event.status,
+              message: event.message ?? current?.message,
+              updatedAt: Date.now(),
+            };
+            next.set(event.id, updated);
+          }
+        } else if (event.kind === "annotate" && current) {
+          next.set(event.id, {
+            ...current,
+            message: event.message,
+            updatedAt: Date.now(),
+          });
+        }
+
+        return next;
+      });
+    });
+    return () => {
+      unsubscribeRef.current?.();
+      unsubscribeRef.current = null;
+    };
+  }, [source]);
+
+  // Reinitialize tasks when plan changes
+  useEffect(() => {
+    setTasks(() => {
+      const initialTasks = new Map<string, PlanTask>();
+      const nodes = [
+        ...Object.entries(plan.resources),
+        ...Object.entries(plan.deletions),
+      ];
+      for (const [id, item] of nodes) {
+        const planItem = item!;
+        const status: Alchemy.ApplyStatus =
+          planItem.action === "noop" ? "success" : "pending";
+        initialTasks.set(id, {
+          id,
+          type: planItem.resource.type,
+          status,
+          updatedAt: Date.now(),
+        });
+      }
+      return initialTasks;
+    });
+  }, [plan]);
+
+  const rows = useMemo(
+    () =>
+      Array.from(tasks.values()).sort((a, b) => {
+        // First sort by status priority
+        const priorityDiff =
+          statusPriority(a.status) - statusPriority(b.status);
+        if (priorityDiff !== 0) return priorityDiff;
+
+        // Then sort by ID for consistent ordering within same priority
+        return a.id.localeCompare(b.id);
+      }),
+    [tasks],
+  );
+
+  return (
+    <Box flexDirection="column">
+      {rows.map((task) => {
+        const color = statusColor(task.status);
+        const icon = statusIcon(task.status, spinner);
+
+        return (
+          <Box key={task.id} flexDirection="row">
+            <Box width={2}>
+              <Text color={color}>{icon} </Text>
+            </Box>
+            <Box width={12}>
+              <Text bold>{task.id}</Text>
+            </Box>
+            <Box width={25}>
+              <Text dimColor>({task.type})</Text>
+            </Box>
+            <Box width={12}>
+              <Text color={color}>{task.status}</Text>
+            </Box>
+            <Box>
+              {task.message ? <Text dimColor>• {task.message}</Text> : null}
+            </Box>
+          </Box>
+        );
+      })}
+    </Box>
+  );
+}
+
+function statusPriority(status: Alchemy.ApplyStatus): number {
+  switch (status) {
+    case "success":
+    case "created":
+    case "updated":
+    case "deleted":
+      return 0; // highest priority (success)
+    case "fail":
+      return 1;
+    case "creating":
+    case "updating":
+    case "deleting":
+      return 2; // in progress
+    case "pending":
+      return 3; // lowest priority (pending)
+    default:
+      return 4;
+  }
+}
+
+function statusColor(
+  status: Alchemy.ApplyStatus,
+): Parameters<typeof Text>[0]["color"] {
+  switch (status) {
+    case "pending":
+      return "gray";
+    case "creating":
+    case "created":
+      return "green";
+    case "updating":
+    case "updated":
+      return "yellow";
+    case "deleting":
+    case "deleted":
+      return "red";
+    case "success":
+      return "green";
+    case "fail":
+      return "redBright";
+    default:
+      return undefined;
+  }
+}
+
+function statusIcon(status: Alchemy.ApplyStatus, spinnerChar: string): string {
+  if (isInProgress(status)) return spinnerChar;
+  if (status === "fail") return "✗";
+  return "✓"; // created/updated/deleted/success
+}
+
+function isInProgress(status: Alchemy.ApplyStatus): boolean {
+  return (
+    status === "pending" ||
+    status === "creating" ||
+    status === "updating" ||
+    status === "deleting"
+  );
+}

package/src/cli/index.ts

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

package/src/cli/plan.ts

@@ -0,0 +1,16 @@
+export type PlanAction = "create" | "update" | "delete" | "noop";
+
+export interface PlanBinding {
+  // Single label including target, eg: "Lambda.InvokeFunction(api)"
+  id: string;
+  action: PlanAction;
+}
+
+export interface PlanItem {
+  id: string;
+  type: string;
+  action: PlanAction;
+  bindings?: PlanBinding[]; // optional bindings
+}
+
+export type PlanSummary = Map<string, PlanItem>;

package/src/cli/progress.tsx

@@ -0,0 +1,46 @@
+// biome-ignore lint/correctness/noUnusedImports: UMD global
+import React from "react";
+
+import { render } from "ink";
+
+import * as Alchemy from "alchemy-effect";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+
+import { PlanProgress } from "./components/PlanProgress.tsx";
+
+export interface ProgressEventSource {
+  subscribe(listener: (event: Alchemy.ApplyEvent) => void): () => void;
+}
+
+export const reportProgress = Layer.succeed(
+  Alchemy.PlanStatusReporter,
+  Alchemy.PlanStatusReporter.of({
+    // oxlint-disable-next-line require-yield
+    start: Effect.fn(function* (plan) {
+      const listeners = new Set<(event: Alchemy.ApplyEvent) => void>();
+      const { unmount } = render(
+        <PlanProgress
+          plan={plan}
+          source={{
+            subscribe(listener) {
+              listeners.add(listener);
+              return () => listeners.delete(listener);
+            },
+          }}
+        />,
+      );
+      return {
+        done: () =>
+          Effect.gen(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);
+          }),
+      };
+    }),
+  }),
+);

package/src/cli/spinner.ts

@@ -0,0 +1,14 @@
+import { useEffect, useState } from "react";
+
+const spinnerFrames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+export 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/cloudflare/api.ts

@@ -0,0 +1,152 @@
+import { APIConnectionError, Cloudflare, type APIError } from "cloudflare";
+import {
+  isRequestOptions,
+  type APIPromise,
+  type RequestOptions,
+} from "cloudflare/core";
+import type { ErrorData } from "cloudflare/resources";
+import { Layer } from "effect";
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+
+export class CloudflareAccountId extends Context.Tag("cloudflare/account-id")<
+  CloudflareAccountId,
+  string
+>() {
+  static readonly fromEnv = Layer.effect(
+    CloudflareAccountId,
+    Effect.gen(function* () {
+      const accountId = process.env.CLOUDFLARE_ACCOUNT_ID;
+      if (!accountId) {
+        return yield* Effect.die("CLOUDFLARE_ACCOUNT_ID is not set");
+      }
+      return accountId;
+    }),
+  );
+}
+
+export class CloudflareApi extends Effect.Service<CloudflareApi>()(
+  "cloudflare/api",
+  {
+    effect: (options?: {
+      baseUrl?: string;
+      apiToken?: string;
+      apiKey?: string;
+      apiEmail?: string;
+    }) =>
+      Effect.succeed(
+        createRecursiveProxy(
+          new Cloudflare({
+            baseURL: options?.baseUrl ?? import.meta.env.CLOUDFLARE_BASE_URL,
+            apiToken: options?.apiToken ?? import.meta.env.CLOUDFLARE_API_TOKEN,
+            apiKey: options?.apiKey ?? import.meta.env.CLOUDFLARE_API_KEY,
+            apiEmail: options?.apiEmail ?? import.meta.env.CLOUDFLARE_API_EMAIL,
+          }),
+        ),
+      ),
+  },
+) {}
+
+export class CloudflareApiError extends Data.Error<{
+  _tag:
+    | "Connection"
+    | "BadRequest"
+    | "Authentication"
+    | "PermissionDenied"
+    | "NotFound"
+    | "Conflict"
+    | "UnprocessableEntity"
+    | "RateLimit"
+    | "InternalServerError"
+    | "Unknown";
+  message: string;
+  errors: ErrorData[];
+  cause: APIError;
+}> {
+  static from(cause: APIError): CloudflareApiError {
+    const error = new CloudflareApiError({
+      _tag: CloudflareApiError.getTag(cause),
+      message: cause.message,
+      errors: cause.errors,
+      cause: cause,
+    });
+    return error;
+  }
+
+  private static getTag(error: APIError): CloudflareApiError["_tag"] {
+    if (error instanceof APIConnectionError) {
+      return "Connection";
+    }
+    switch (error.status) {
+      case 400:
+        return "BadRequest";
+      case 401:
+        return "Authentication";
+      case 403:
+        return "PermissionDenied";
+      case 404:
+        return "NotFound";
+      case 409:
+        return "Conflict";
+      case 422:
+        return "UnprocessableEntity";
+      case 429:
+        return "RateLimit";
+      case 500:
+        return "InternalServerError";
+      default:
+        return "Unknown";
+    }
+  }
+}
+
+type ToEffect<T> = {
+  [K in keyof T]: T[K] extends (...args: any[]) => any
+    ? (
+        ...args: Parameters<T[K]>
+      ) => Effect.Effect<UnwrapAPIPromise<ReturnType<T[K]>>, CloudflareApiError>
+    : T[K] extends Record<string, any>
+      ? ToEffect<T[K]>
+      : T[K];
+};
+
+type UnwrapAPIPromise<T> = T extends APIPromise<infer U> ? U : never;
+
+const createRecursiveProxy = <T extends object>(target: T): ToEffect<T> => {
+  return new Proxy(target as any, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value === "function") {
+        return Effect.fnUntraced(function* (...args: any[]) {
+          return yield* Effect.tryPromise({
+            try: async (signal) => {
+              let modifiedArgs: any[];
+              if (isRequestOptions(args[args.length - 1])) {
+                const options = args[args.length - 1] as RequestOptions;
+                modifiedArgs = [
+                  ...args.slice(0, -1),
+                  {
+                    ...options,
+                    signal: options?.signal
+                      ? AbortSignal.any([signal, options.signal])
+                      : signal,
+                  },
+                ];
+              } else {
+                modifiedArgs = [...args, { signal }];
+              }
+              const result = await value.apply(target, modifiedArgs);
+              return result;
+            },
+            catch: (cause) => {
+              const error = CloudflareApiError.from(cause as APIError);
+              return error;
+            },
+          });
+        });
+      }
+      return createRecursiveProxy(value);
+    },
+  });
+};

package/src/cloudflare/context.ts

@@ -0,0 +1,49 @@
+import type { ExecutionContext } from "@cloudflare/workers-types";
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+
+export class CloudflareContext extends Context.Tag("Cloudflare.Context")<
+  CloudflareContext,
+  {
+    env: unknown;
+    ctx: ExecutionContext;
+  }
+>() {}
+
+export const getCloudflareEnvKey = Effect.fnUntraced(function* <T>(
+  key: string,
+) {
+  return yield* Effect.serviceOptional(CloudflareContext).pipe(
+    Effect.mapError(
+      () =>
+        new CloudflareContextNotFound({
+          message: "Cloudflare context not found",
+        }),
+    ),
+    Effect.flatMap((context) => {
+      const env = context.env as Record<string, unknown>;
+      if (!(key in env)) {
+        return new CloudflareContextKeyNotFound({
+          message: `${key} is not set in cloudflare context (found ${Object.keys(env).join(", ")})`,
+          key,
+        });
+      }
+      return Effect.succeed(env[key] as T);
+    }),
+    Effect.orDie,
+  );
+});
+
+export class CloudflareContextNotFound extends Data.TaggedError(
+  "Cloudflare.Context.NotFound",
+)<{
+  message: string;
+}> {}
+
+export class CloudflareContextKeyNotFound extends Data.TaggedError(
+  "Cloudflare.Context.KeyNotFound",
+)<{
+  message: string;
+  key: string;
+}> {}

package/src/cloudflare/index.ts

@@ -0,0 +1,6 @@
+export * as KV from "./kv/index.ts";
+export * as R2 from "./r2/index.ts";
+export * as Assets from "./worker/assets.fetch.ts";
+export * as Worker from "./worker/index.ts";
+
+export type * as Alchemy from "../index.ts";

package/src/cloudflare/kv/index.ts

@@ -0,0 +1,3 @@
+export * from "./namespace.binding.ts";
+export * from "./namespace.client.ts";
+export * from "./namespace.ts";

package/src/cloudflare/kv/namespace.binding.ts

@@ -0,0 +1,25 @@
+import { Binding, type Capability, type To } from "alchemy-effect";
+import { Worker } from "../worker/worker.ts";
+import type { Namespace, NamespaceProps } from "./namespace.ts";
+
+export interface Bind<B = Namespace<string, NamespaceProps>>
+  extends Capability<"Cloudflare.KV.Namespace.Bind", B> {}
+
+export const Bind = Binding<
+  <B extends Namespace<string, NamespaceProps>>(
+    namespace: B,
+  ) => Binding<Worker, Bind<To<B>>>
+>(Worker, "Cloudflare.KV.Namespace.Bind");
+
+export const bindFromWorker = () =>
+  Bind.provider.succeed({
+    attach: ({ source }) => ({
+      bindings: [
+        {
+          type: "kv_namespace",
+          name: source.id,
+          namespace_id: source.attr.namespaceId,
+        },
+      ],
+    }),
+  });

package/src/cloudflare/kv/namespace.client.ts

@@ -0,0 +1,70 @@
+import type * as runtime from "@cloudflare/workers-types";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import { declare, type To } from "../../policy.ts";
+import { getCloudflareEnvKey } from "../context.ts";
+import { replaceEffectStream } from "../stream.ts";
+import { Bind } from "./namespace.binding.ts";
+import type * as KV from "./namespace.ts";
+
+export const get = Effect.fnUntraced(function* <KV extends KV.Namespace>(
+  namespace: KV,
+  key: string,
+) {
+  const client = yield* getKvNamespaceFromEnv(namespace);
+  return yield* Effect.promise(() => client.get(key));
+});
+
+export const getWithMetadata = Effect.fnUntraced(function* <
+  KV extends KV.Namespace,
+  Metadata = unknown,
+>(
+  namespace: KV,
+  key: string,
+  options?: runtime.KVNamespaceGetOptions<undefined>,
+) {
+  const client = yield* getKvNamespaceFromEnv(namespace);
+  return yield* Effect.promise(() =>
+    client.getWithMetadata<Metadata>(key, options),
+  );
+});
+
+export const put = Effect.fnUntraced(function* <KV extends KV.Namespace>(
+  namespace: KV,
+  key: string,
+  value:
+    | string
+    | ArrayBuffer
+    | ArrayBufferView
+    | runtime.ReadableStream
+    | Stream.Stream<any>,
+  options?: runtime.KVNamespacePutOptions,
+) {
+  const client = yield* getKvNamespaceFromEnv(namespace);
+  return yield* Effect.promise(() =>
+    client.put(key, replaceEffectStream(value), options),
+  );
+});
+
+export const del = Effect.fnUntraced(function* <KV extends KV.Namespace>(
+  namespace: KV,
+  key: string,
+) {
+  const client = yield* getKvNamespaceFromEnv(namespace);
+  return yield* Effect.promise(() => client.delete(key));
+});
+
+export const list = Effect.fnUntraced(function* <
+  KV extends KV.Namespace,
+  Metadata = unknown,
+>(namespace: KV, options?: runtime.KVNamespaceListOptions) {
+  const client = yield* getKvNamespaceFromEnv(namespace);
+  return yield* Effect.promise(() => client.list<Metadata>(options));
+});
+
+const getKvNamespaceFromEnv = Effect.fnUntraced(function* <
+  KV extends KV.Namespace,
+>(namespace: KV) {
+  yield* declare<Bind<To<KV>>>();
+  return yield* getCloudflareEnvKey<runtime.KVNamespace>(namespace.id);
+});