alchemy-effect 0.5.0 → 0.6.2

package/src/cli/components/PlanProgress.tsx

@@ -1,224 +0,0 @@
-// biome-ignore lint/style/useImportType: UMD global
-import React, { useEffect, useMemo, useRef, useState } from "react";
-
-import { Box, Text } from "ink";
-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<StatusChangeEvent, "id" | "type" | "status">> {
-  message?: string;
-  updatedAt: number;
-}
-
-interface PlanProgressProps {
-  source: ProgressEventSource;
-  plan: IPlan;
-}
-
-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: 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: 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: 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: 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: ApplyStatus, spinnerChar: string): string {
-  if (isInProgress(status)) return spinnerChar;
-  if (status === "fail") return "✗";
-  return "✓"; // created/updated/deleted/success
-}
-
-function isInProgress(status: ApplyStatus): boolean {
-  return (
-    status === "pending" ||
-    status === "creating" ||
-    status === "updating" ||
-    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,2 +0,0 @@
-export * from "./service.ts";
-export * from "./ink-service.tsx";

package/src/cli/ink-service.tsx

@@ -1,61 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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;
-    }),
-  );

package/src/cloudflare/api.ts

@@ -1,156 +0,0 @@
-import { APIConnectionError, Cloudflare, type APIError } from "cloudflare";
-import {
-  isRequestOptions,
-  type APIPromise,
-  type RequestOptions,
-} from "cloudflare/core";
-import type { ErrorData } from "cloudflare/resources";
-import * as Data from "effect/Data";
-import * as Option from "effect/Option";
-import * as Effect from "effect/Effect";
-import { Config } from "effect";
-
-export const CLOUDFLARE_BASE_URL = Config.string("CLOUDFLARE_BASE_URL").pipe(
-  Config.option,
-);
-export const CLOUDFLARE_API_TOKEN = Config.string("CLOUDFLARE_API_TOKEN").pipe(
-  Config.option,
-);
-export const CLOUDFLARE_API_KEY = Config.string("CLOUDFLARE_API_KEY").pipe(
-  Config.option,
-);
-export const CLOUDFLARE_API_EMAIL = Config.string("CLOUDFLARE_API_EMAIL").pipe(
-  Config.option,
-);
-
-export class CloudflareApi extends Effect.Service<CloudflareApi>()(
-  "cloudflare/api",
-  {
-    effect: Effect.fn(function* (options?: {
-      baseUrl?: string;
-      apiToken?: string;
-      apiKey?: string;
-      apiEmail?: string;
-    }) {
-      return createRecursiveProxy(
-        new Cloudflare({
-          baseURL:
-            options?.baseUrl ??
-            (yield* CLOUDFLARE_BASE_URL).pipe(Option.getOrUndefined),
-          apiToken:
-            options?.apiToken ??
-            (yield* CLOUDFLARE_API_TOKEN).pipe(Option.getOrUndefined),
-          apiKey:
-            options?.apiKey ??
-            (yield* CLOUDFLARE_API_KEY).pipe(Option.getOrUndefined),
-          apiEmail:
-            options?.apiEmail ??
-            (yield* CLOUDFLARE_API_EMAIL).pipe(Option.getOrUndefined),
-        }),
-      );
-    }),
-  },
-) {}
-
-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/config.ts

@@ -1,7 +0,0 @@
-declare module "../stage.ts" {
-  interface StageConfig {
-    cloudflare?: {
-      account: string;
-    };
-  }
-}

package/src/cloudflare/context.ts

@@ -1,49 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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 * from "./account.ts";
-export * from "./live.ts";
-
-import "./config.ts";

package/src/cloudflare/kv/index.ts

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

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

@@ -1,27 +0,0 @@
-import { Binding } from "../../binding.ts";
-import type { Capability } from "../../capability.ts";
-import type { To } from "../../policy.ts";
-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

@@ -1,70 +0,0 @@
-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);
-});