alchemy 2.0.0-beta.36 → 2.0.0-beta.38

package/src/Cli/NamespaceTree.ts

@@ -1,20 +1,30 @@
 import { toPath } from "../FQN.ts";
-import type { BindingAction, CRUD } from "../Plan.ts";
+import type {
+  BindingAction,
+  CRUD,
+  ActionApply,
+  ActionDelete,
+} from "../Plan.ts";
 
 export interface TreeBinding {
   sid: string;
   action: BindingAction;
 }
 
+export type ActionTreeItem = ActionApply | ActionDelete;
+export type ActionVerb = ActionTreeItem["action"]; // "run" | "noop" | "delete"
+
 /**
  * A tree node representing a namespace.
- * Resources live directly inside the namespace where they were created.
+ * Resources and tasks live directly inside the namespace where they were
+ * created.
  */
 export interface TreeNode {
   id: string;
   path: string[];
   children: Map<string, TreeNode>;
   resources: CRUD[];
+  actions: ActionTreeItem[];
 }
 
 export type DerivedAction =
@@ -25,12 +35,16 @@ export type DerivedAction =
   | "noop"
   | "mixed";
 
-export function buildNamespaceTree(items: CRUD[]): TreeNode {
+export function buildNamespaceTree(
+  items: CRUD[],
+  actions: ReadonlyArray<ActionTreeItem> = [],
+): TreeNode {
   const root: TreeNode = {
     id: "",
     path: [],
     children: new Map(),
     resources: [],
+    actions: [],
   };
 
   const getNode = (path: string[]) => {
@@ -44,6 +58,7 @@ export function buildNamespaceTree(items: CRUD[]): TreeNode {
           path: path.slice(0, i + 1),
           children: new Map(),
           resources: [],
+          actions: [],
         };
         current.children.set(segment, child);
       }
@@ -55,6 +70,9 @@ export function buildNamespaceTree(items: CRUD[]): TreeNode {
   for (const item of items) {
     getNode(toPath(item.resource.Namespace)).resources.push(item);
   }
+  for (const action of actions) {
+    getNode(toPath(action.def.Namespace)).actions.push(action);
+  }
 
   return root;
 }
@@ -65,6 +83,17 @@ export function deriveNamespaceAction(node: TreeNode): DerivedAction {
   for (const resource of node.resources) {
     actions.add(deriveResourceChildrenAction(resource, node));
   }
+  for (const action of node.actions) {
+    // Map task actions onto the resource action space for the rollup:
+    // run → create, delete → delete, noop → noop.
+    actions.add(
+      action.action === "run"
+        ? "create"
+        : action.action === "delete"
+          ? "delete"
+          : "noop",
+    );
+  }
   for (const child of node.children.values()) {
     const childAction = deriveNamespaceAction(child);
     if (childAction === "mixed") {
@@ -77,15 +106,17 @@ export function deriveNamespaceAction(node: TreeNode): DerivedAction {
 }
 
 export interface FlattenedItem {
-  type: "namespace" | "resource" | "binding";
+  type: "namespace" | "resource" | "binding" | "action";
   depth: number;
   id: string;
   path: string[];
-  action: CRUD["action"] | BindingAction | DerivedAction;
+  action: CRUD["action"] | BindingAction | DerivedAction | ActionVerb;
   resourceType?: string;
   bindingSid?: string;
   bindingCount?: number;
   hasChildren?: boolean;
+  /** For task items, the Task's Type (e.g. "Sync"). */
+  actionType?: string;
 }
 
 export function flattenTree(
@@ -154,10 +185,26 @@ const flattenNamespace = (
       flattenNamespace(childNamespace, depth + 1, result);
     }
   }
+
+  // Actions are listed after resources at the same depth.
+  const sortedActions = [...node.actions].sort((a, b) =>
+    a.def.LogicalId.localeCompare(b.def.LogicalId),
+  );
+  for (const action of sortedActions) {
+    result.push({
+      type: "action",
+      depth,
+      id: action.def.LogicalId,
+      path: [...node.path, action.def.LogicalId],
+      action: action.action,
+      actionType: action.def.Type,
+    });
+  }
 };
 
 const isEmpty = (node: TreeNode) =>
   node.resources.length === 0 &&
+  node.actions.length === 0 &&
   Array.from(node.children.values()).every(isEmpty);
 
 const countVisibleChildren = (node: TreeNode) => {

package/src/Cli/commands/_shared.ts

@@ -21,7 +21,7 @@ export const USER = Config.string("USER").pipe(
 
 export const STAGE = Config.string("stage").pipe(
   Config.option,
-  (a) => a.asEffect(),
+  (a) => a,
   Effect.map(Option.getOrUndefined),
 );
 
@@ -96,7 +96,7 @@ export const stage = Flag.string("stage").pipe(
         ),
         Effect.flatMap((s) =>
           s === undefined
-            ? USER.asEffect().pipe(
+            ? USER.pipe(
                 Effect.map((user) => `dev_${user}`),
                 Effect.catch(() => Effect.succeed("unknown")),
               )

package/src/Cli/commands/deploy.ts

@@ -83,7 +83,7 @@ export const execStack = Effect.fn(function* ({
   const services = Layer.mergeAll(
     Layer.effect(
       AlchemyContext,
-      AlchemyContext.asEffect().pipe(
+      AlchemyContext.pipe(
         Effect.map((ctx) => ({
           ...ctx,
           dev,

package/src/Cli/commands/logs.ts

@@ -119,16 +119,16 @@ export const logsCommand = Command.make(
               stage: stack.stage,
               fqn,
             });
-            if (!resourceState?.attr) continue;
+            if (!(resourceState as any)?.attr) continue;
 
             const provider = yield* findProviderByType(resource.Type);
             if (!provider.logs) continue;
 
             const lines = yield* provider.logs({
               id: resource.LogicalId,
-              instanceId: resourceState.instanceId,
-              props: resourceState.props as any,
-              output: resourceState.attr as any,
+              instanceId: (resourceState as any).instanceId,
+              props: (resourceState as any).props,
+              output: (resourceState as any).attr,
               options: { limit, since: sinceDate },
             });
 

package/src/Cli/commands/tail.ts

@@ -95,7 +95,7 @@ export const tailCommand = Command.make(
               stage: stack.stage,
               fqn,
             });
-            if (!resourceState?.attr) continue;
+            if (!(resourceState as any)?.attr) continue;
 
             const provider = yield* findProviderByType(resource.Type);
             if (!provider.tail) continue;
@@ -104,9 +104,9 @@ export const tailCommand = Command.make(
               logicalId: resource.LogicalId,
               stream: provider.tail({
                 id: resource.LogicalId,
-                instanceId: resourceState.instanceId,
-                props: resourceState.props as any,
-                output: resourceState.attr as any,
+                instanceId: (resourceState as any).instanceId,
+                props: (resourceState as any).props,
+                output: (resourceState as any).attr,
               }),
             });
           }

package/src/Cli/tui/components/Plan.tsx

@@ -6,11 +6,14 @@ import type {
   Plan as AlchemyPlan,
   BindingAction,
   CRUD,
+  ActionApply,
+  ActionDelete,
 } from "../../../Plan.ts";
 import {
   buildNamespaceTree,
   flattenTree,
   type DerivedAction,
+  type ActionVerb,
 } from "../../NamespaceTree.ts";
 
 export interface PlanProps {
@@ -25,13 +28,21 @@ export function Plan({ plan }: PlanProps): JSX.Element {
       ] as CRUD[],
     [plan],
   );
+  const taskItems = useMemo(
+    () =>
+      [
+        ...Object.values(plan.actions ?? {}),
+        ...Object.values(plan.actionDeletions ?? {}),
+      ].filter((t): t is ActionApply | ActionDelete => t !== undefined),
+    [plan],
+  );
 
   const flatItems = useMemo(() => {
-    const tree = buildNamespaceTree(items);
+    const tree = buildNamespaceTree(items, taskItems);
     return flattenTree(tree);
-  }, [items]);
+  }, [items, taskItems]);
 
-  if (items.length === 0) {
+  if (items.length === 0 && taskItems.length === 0) {
     return <Text color="gray">No changes planned</Text>;
   }
 
@@ -42,31 +53,46 @@ export function Plan({ plan }: PlanProps): JSX.Element {
     noop: 0,
     replace: 0,
   });
+  const taskCounts = taskItems.reduce(
+    (acc, item) => (acc[item.action]++, acc),
+    { run: 0, noop: 0, delete: 0 },
+  );
 
   const actions = (["create", "update", "delete", "replace"] as const).filter(
     (action) => counts[action] > 0,
   );
+  const taskHeaderEntries = [
+    taskCounts.run > 0 ? `${taskCounts.run} to run` : undefined,
+    taskCounts.delete > 0 ? `${taskCounts.delete} to drop` : undefined,
+  ].filter((s): s is string => !!s);
 
   return (
     <Box flexDirection="column">
       <Box marginTop={1}>
         <Text underline>Plan</Text>
         <Text>: </Text>
-        {actions.flatMap((action, i) => {
-          const count = counts[action];
-          const color = actionColor(action);
-          if (count === 0) return [];
-          const box = (
-            <Box key={action}>
-              <Text color={color}>
-                {count} to {action}
-              </Text>
+        {[
+          ...actions.map((action) => {
+            const count = counts[action];
+            const color = actionColor(action);
+            return (
+              <Box key={action}>
+                <Text color={color}>
+                  {count} to {action}
+                </Text>
+              </Box>
+            );
+          }),
+          ...taskHeaderEntries.map((label, i) => (
+            <Box key={`task-${i}`}>
+              <Text color="cyan">{label}</Text>
             </Box>
-          );
-          return i === actions.length - 1
+          )),
+        ].flatMap((box, i, arr) =>
+          i === arr.length - 1
             ? [box]
-            : [box, <Text key={`${action}-separator`}> | </Text>];
-        })}
+            : [box, <Text key={`sep-${i}`}> | </Text>],
+        )}
       </Box>
       <Box flexDirection="column" marginTop={1}>
         {flatItems.map((item) => {
@@ -99,6 +125,26 @@ export function Plan({ plan }: PlanProps): JSX.Element {
             );
           }
 
+          if (item.type === "action") {
+            return (
+              <Box key={key} flexDirection="row">
+                <Text>{indent}</Text>
+                <Box width={2}>
+                  <Text color={color}>{icon} </Text>
+                </Box>
+                <Box>
+                  <Text bold>{item.id}</Text>
+                </Box>
+                <Box marginLeft={1}>
+                  <Text color="blackBright">({item.actionType})</Text>
+                </Box>
+                <Box marginLeft={1}>
+                  <Text color="cyan">[action]</Text>
+                </Box>
+              </Box>
+            );
+          }
+
           // Resource item
           return (
             <Box key={key} flexDirection="row">
@@ -127,7 +173,7 @@ export function Plan({ plan }: PlanProps): JSX.Element {
 
 type Color = Parameters<typeof Text>[0]["color"];
 
-type AnyAction = CRUD["action"] | BindingAction | DerivedAction;
+type AnyAction = CRUD["action"] | BindingAction | DerivedAction | ActionVerb;
 
 const getActionColor = (action: AnyAction): Color =>
   ({
@@ -137,6 +183,7 @@ const getActionColor = (action: AnyAction): Color =>
     delete: "red",
     replace: "magenta",
     mixed: "cyan",
+    run: "cyan",
   })[action] ?? "gray";
 
 const getActionIcon = (action: AnyAction): string =>
@@ -147,6 +194,7 @@ const getActionIcon = (action: AnyAction): string =>
     noop: "•",
     replace: "!",
     mixed: "*",
+    run: "λ",
   })[action] ?? "?";
 
 const actionColor = (action: CRUD["action"]): Color => getActionColor(action);

package/src/Cli/tui/components/PlanProgress.tsx

@@ -2,7 +2,7 @@
 import { useEffect, useMemo, useRef, useState, type JSX } from "react";
 
 import { Box, Text } from "ink";
-import type { CRUD, Plan } from "../../../Plan.ts";
+import type { CRUD, Plan, ActionApply, ActionDelete } from "../../../Plan.ts";
 
 import type {
   ApplyEvent,
@@ -13,6 +13,7 @@ import {
   buildNamespaceTree,
   flattenTree,
   type FlattenedItem,
+  type ActionVerb,
 } from "../../NamespaceTree.ts";
 
 interface ProgressEventSource {
@@ -51,6 +52,14 @@ export type ProgressRow =
       action: CRUD["action"];
       /** For `noop` resources, persisted state status to show instead of `pending`. */
       persistedApplyStatus?: "created" | "updated";
+    }
+  | {
+      key: string;
+      type: "task";
+      id: string;
+      depth: number;
+      actionType: string;
+      action: ActionVerb;
     };
 
 const getTaskKey = (item: FlattenedItem) => item.path.join("/");
@@ -65,42 +74,55 @@ export const buildProgressRows = (plan: Plan): ProgressRow[] => {
         item !== undefined,
     ),
   ] as PlanItem[];
-  const tree = buildNamespaceTree(items);
+  const taskItems = [
+    ...Object.values(plan.actions ?? {}),
+    ...Object.values(plan.actionDeletions ?? {}),
+  ].filter((t): t is ActionApply | ActionDelete => t !== undefined);
+  const tree = buildNamespaceTree(items, taskItems);
   return flattenTree(tree)
     .filter((item) => item.type !== "binding")
-    .map((item) =>
-      item.type === "namespace"
-        ? {
-            key: getTaskKey(item),
-            type: "namespace" as const,
-            id: item.id,
-            depth: item.depth,
-            action: item.action,
-          }
-        : {
-            key: getTaskKey(item),
-            type: "resource" as const,
-            id: item.id,
-            depth: item.depth,
-            resourceType: item.resourceType ?? "unknown",
-            action: item.action as CRUD["action"],
-            persistedApplyStatus:
-              item.action === "noop"
-                ? (() => {
-                    const crud = findCrudByLogicalId(plan, item.id);
-                    return crud?.action === "noop"
-                      ? crud.state.status
-                      : undefined;
-                  })()
-                : undefined,
-          },
-    );
+    .map((item) => {
+      if (item.type === "namespace") {
+        return {
+          key: getTaskKey(item),
+          type: "namespace" as const,
+          id: item.id,
+          depth: item.depth,
+          action: item.action,
+        };
+      }
+      if (item.type === "action") {
+        return {
+          key: getTaskKey(item),
+          type: "task" as const,
+          id: item.id,
+          depth: item.depth,
+          actionType: item.actionType ?? "unknown",
+          action: item.action as ActionVerb,
+        };
+      }
+      return {
+        key: getTaskKey(item),
+        type: "resource" as const,
+        id: item.id,
+        depth: item.depth,
+        resourceType: item.resourceType ?? "unknown",
+        action: item.action as CRUD["action"],
+        persistedApplyStatus:
+          item.action === "noop"
+            ? (() => {
+                const crud = findCrudByLogicalId(plan, item.id);
+                return crud?.action === "noop" ? crud.state.status : undefined;
+              })()
+            : undefined,
+      };
+    });
 };
 
 const buildLogicalIdIndex = (rows: ProgressRow[]) => {
   const index = new Map<string, string[]>();
   for (const row of rows) {
-    if (row.type !== "resource") continue;
+    if (row.type !== "resource" && row.type !== "task") continue;
     const keys = index.get(row.id);
     if (keys) {
       keys.push(row.key);
@@ -142,7 +164,27 @@ export function toPlanTask(
 const buildInitialTasks = (rows: ProgressRow[]) =>
   new Map(
     rows.flatMap((row) =>
-      row.type === "resource" ? [[row.key, toPlanTask(row)]] : [],
+      row.type === "resource"
+        ? [[row.key, toPlanTask(row)]]
+        : row.type === "task"
+          ? [
+              [
+                row.key,
+                {
+                  key: row.key,
+                  id: row.id,
+                  type: row.actionType,
+                  // `noop` tasks are skipped — render as gray `•` from the start
+                  // rather than briefly flashing the `ran` cyan styling.
+                  status:
+                    row.action === "noop"
+                      ? ("skipped" as ApplyStatus)
+                      : ("pending" as ApplyStatus),
+                  updatedAt: Date.now(),
+                },
+              ],
+            ]
+          : [],
     ),
   );
 
@@ -220,6 +262,53 @@ export function PlanProgress(props: PlanProgressProps): JSX.Element {
           );
         }
 
+        if (row.type === "task") {
+          const t = tasks.get(row.key);
+          const status: ApplyStatus =
+            t?.status ?? (row.action === "noop" ? "ran" : "pending");
+          const color = statusColor(status);
+          const icon = taskIcon(row.action, status, spinner);
+          const label =
+            row.action === "delete"
+              ? status === "deleted"
+                ? "deleted"
+                : "drop"
+              : status === "ran"
+                ? row.action === "noop"
+                  ? "skip"
+                  : "ran"
+                : status === "running"
+                  ? "running"
+                  : status === "fail"
+                    ? "fail"
+                    : row.action === "noop"
+                      ? "skip"
+                      : "run";
+
+          return (
+            <Box key={row.key} flexDirection="column">
+              <Box flexDirection="row">
+                <Text>{indent}</Text>
+                <Box width={2}>
+                  <Text color={color}>{icon} </Text>
+                </Box>
+                <Text bold>{row.id}</Text>
+                <Text dimColor> ({row.actionType})</Text>
+                <Text color={color}> {label}</Text>
+                <Text color="cyan" dimColor>
+                  {" "}
+                  [action]
+                </Text>
+              </Box>
+              {t?.message ? (
+                <Box paddingLeft={row.depth * 2 + 2}>
+                  <Text dimColor>• {t.message}</Text>
+                </Box>
+              ) : null}
+            </Box>
+          );
+        }
+
         const task = tasks.get(row.key) ?? toPlanTask(row);
         const displayStatus = getDisplayStatus(row, task.status);
         const color = statusColor(displayStatus);
@@ -276,6 +365,11 @@ function statusColor(
     case "deleting":
     case "deleted":
       return "red";
+    case "running":
+    case "ran":
+      return "cyan";
+    case "skipped":
+      return "gray";
     case "fail":
       return "redBright";
     default:
@@ -283,6 +377,21 @@ function statusColor(
   }
 }
 
+function taskIcon(
+  action: ActionVerb,
+  status: ApplyStatus,
+  spinnerChar: string,
+): string {
+  if (status === "running") return spinnerChar;
+  if (status === "fail") return "✗";
+  if (status === "skipped") return "•";
+  if (status === "ran") return action === "noop" ? "•" : "✓";
+  if (status === "deleted") return "✓";
+  if (action === "delete") return "-";
+  if (action === "noop") return "•";
+  return "λ";
+}
+
 function statusIcon(status: ApplyStatus, spinnerChar: string): string {
   if (isInProgress(status)) return spinnerChar;
   if (status === "fail") return "✗";
@@ -294,7 +403,8 @@ function isInProgress(status: ApplyStatus): boolean {
     status === "pending" ||
     status === "creating" ||
     status === "updating" ||
-    status === "deleting"
+    status === "deleting" ||
+    status === "running"
   );
 }
 

package/src/Cloudflare/Access.ts

@@ -75,7 +75,7 @@ export const AccessLive = Layer.effect(
 
     const getEnv = (name: string) =>
       Config.string(name)
-        .asEffect()
+
         .pipe(Effect.catchTag("ConfigError", () => Effect.succeed(undefined)));
 
     return Access.of({

package/src/Cloudflare/AnalyticsEngine/AnalyticsEngineDataset.ts

@@ -0,0 +1,82 @@
+import * as Effect from "effect/Effect";
+import { AnalyticsEngineDatasetBinding } from "./AnalyticsEngineDatasetBinding.ts";
+
+type AnalyticsEngineDatasetTypeId = typeof AnalyticsEngineDatasetTypeId;
+const AnalyticsEngineDatasetTypeId =
+  "Cloudflare.AnalyticsEngineDataset" as const;
+
+export type AnalyticsEngineDatasetProps = {
+  /**
+   * Dataset name. If omitted, the logical ID is used.
+   */
+  dataset?: string;
+};
+
+/**
+ * A Cloudflare Workers Analytics Engine dataset binding.
+ *
+ * Analytics Engine datasets are configured as Worker bindings. The binding
+ * exposes `writeDataPoint()` at runtime and does not require separate
+ * provisioning through the Cloudflare API.
+ *
+ * @resource
+ *
+ * @section Binding to a Worker
+ * @example Basic Analytics Engine binding
+ * ```typescript
+ * const Analytics = yield* Cloudflare.AnalyticsEngineDataset("Analytics", {
+ *   dataset: "app-events",
+ * });
+ *
+ * export const Worker = Cloudflare.Worker("Worker", {
+ *   main: "./src/worker.ts",
+ *   bindings: { Analytics },
+ * });
+ * ```
+ *
+ * @example Effect-style worker
+ * ```typescript
+ * const analytics = yield* Cloudflare.AnalyticsEngineDataset.bind(Analytics);
+ * yield* analytics.writeDataPoint({ blobs: ["signup"] });
+ * ```
+ */
+export type AnalyticsEngineDataset = {
+  kind: AnalyticsEngineDatasetTypeId;
+  name: string;
+  dataset: string;
+};
+
+export const isAnalyticsEngineDataset = (
+  value: unknown,
+): value is AnalyticsEngineDataset =>
+  typeof value === "object" &&
+  value !== null &&
+  "kind" in value &&
+  (value as AnalyticsEngineDataset).kind === AnalyticsEngineDatasetTypeId;
+
+export const AnalyticsEngineDataset: {
+  (
+    name: string,
+    props?: AnalyticsEngineDatasetProps,
+  ): Effect.Effect<AnalyticsEngineDataset>;
+  /**
+   * Bind Analytics Engine to the surrounding Worker, returning an
+   * Effect-native client with access to the native Workers runtime binding.
+   */
+  bind: typeof AnalyticsEngineDatasetBinding.bind;
+} = Object.assign(
+  Effect.fnUntraced(function* (
+    name: string,
+    props?: AnalyticsEngineDatasetProps,
+  ) {
+    return {
+      kind: AnalyticsEngineDatasetTypeId,
+      name,
+      dataset: props?.dataset ?? name,
+    } satisfies AnalyticsEngineDataset;
+  }),
+  {
+    bind: (...args: Parameters<typeof AnalyticsEngineDatasetBinding.bind>) =>
+      AnalyticsEngineDatasetBinding.bind(...args),
+  },
+);