alchemy-effect 0.5.0 → 0.6.2

package/src/Cli/NamespaceTree.ts

@@ -0,0 +1,199 @@
+import { toPath } from "../FQN.ts";
+import type { BindingAction, CRUD } from "../Plan.ts";
+
+export interface TreeBinding {
+  sid: string;
+  action: BindingAction;
+}
+
+/**
+ * A tree node representing a namespace.
+ * Resources live directly inside the namespace where they were created.
+ */
+export interface TreeNode {
+  id: string;
+  path: string[];
+  children: Map<string, TreeNode>;
+  resources: CRUD[];
+}
+
+export type DerivedAction =
+  | "create"
+  | "update"
+  | "delete"
+  | "replace"
+  | "noop"
+  | "mixed";
+
+export function buildNamespaceTree(items: CRUD[]): TreeNode {
+  const root: TreeNode = {
+    id: "",
+    path: [],
+    children: new Map(),
+    resources: [],
+  };
+
+  const getNode = (path: string[]) => {
+    let current = root;
+    for (let i = 0; i < path.length; i++) {
+      const segment = path[i];
+      let child = current.children.get(segment);
+      if (!child) {
+        child = {
+          id: segment,
+          path: path.slice(0, i + 1),
+          children: new Map(),
+          resources: [],
+        };
+        current.children.set(segment, child);
+      }
+      current = child;
+    }
+    return current;
+  };
+
+  for (const item of items) {
+    getNode(toPath(item.resource.Namespace)).resources.push(item);
+  }
+
+  return root;
+}
+
+export function deriveNamespaceAction(node: TreeNode): DerivedAction {
+  const actions = new Set<BindingAction | CRUD["action"] | DerivedAction>();
+
+  for (const resource of node.resources) {
+    actions.add(deriveResourceChildrenAction(resource, node));
+  }
+  for (const child of node.children.values()) {
+    const childAction = deriveNamespaceAction(child);
+    if (childAction === "mixed") {
+      return "mixed";
+    }
+    actions.add(childAction);
+  }
+
+  return deriveAction(actions);
+}
+
+export interface FlattenedItem {
+  type: "namespace" | "resource" | "binding";
+  depth: number;
+  id: string;
+  path: string[];
+  action: CRUD["action"] | BindingAction | DerivedAction;
+  resourceType?: string;
+  bindingSid?: string;
+  bindingCount?: number;
+  hasChildren?: boolean;
+}
+
+export function flattenTree(
+  node: TreeNode,
+  depth = 0,
+  result: FlattenedItem[] = [],
+): FlattenedItem[] {
+  flattenNamespace(node, depth, result);
+  return result;
+}
+
+const flattenNamespace = (
+  node: TreeNode,
+  depth: number,
+  result: FlattenedItem[],
+) => {
+  const sortedResources = [...node.resources].sort((a, b) =>
+    a.resource.LogicalId.localeCompare(b.resource.LogicalId),
+  );
+  const sortedChildren = Array.from(node.children.entries()).sort(([a], [b]) =>
+    a.localeCompare(b),
+  );
+  const resourceIds = new Set(
+    sortedResources.map((resource) => resource.resource.LogicalId),
+  );
+
+  for (const [id, child] of sortedChildren) {
+    if (resourceIds.has(id) || isEmpty(child)) {
+      continue;
+    }
+    result.push({
+      type: "namespace",
+      depth,
+      id,
+      path: child.path,
+      action: deriveNamespaceAction(child),
+      hasChildren: true,
+    });
+    flattenNamespace(child, depth + 1, result);
+  }
+
+  for (const resource of sortedResources) {
+    const childNamespace = node.children.get(resource.resource.LogicalId);
+    result.push({
+      type: "resource",
+      depth,
+      id: resource.resource.LogicalId,
+      path: [...node.path, resource.resource.LogicalId],
+      action: resource.action,
+      resourceType: resource.resource.Type,
+      bindingCount: resource.bindings.length,
+    });
+    for (const binding of [...resource.bindings].sort((a, b) =>
+      a.sid.localeCompare(b.sid),
+    )) {
+      result.push({
+        type: "binding",
+        depth: depth + 1,
+        id: binding.sid,
+        path: [...node.path, resource.resource.LogicalId, binding.sid],
+        action: binding.action,
+        bindingSid: binding.sid,
+      });
+    }
+    if (childNamespace) {
+      flattenNamespace(childNamespace, depth + 1, result);
+    }
+  }
+};
+
+const isEmpty = (node: TreeNode) =>
+  node.resources.length === 0 &&
+  Array.from(node.children.values()).every(isEmpty);
+
+const countVisibleChildren = (node: TreeNode) => {
+  const resourceIds = new Set(
+    node.resources.map((resource) => resource.resource.LogicalId),
+  );
+  return (
+    node.resources.length +
+    Array.from(node.children.keys()).filter((id) => !resourceIds.has(id)).length
+  );
+};
+
+const deriveResourceChildrenAction = (
+  resource: CRUD,
+  node: TreeNode,
+): DerivedAction => {
+  const actions = new Set<BindingAction | CRUD["action"] | DerivedAction>([
+    resource.action,
+  ]);
+  for (const binding of resource.bindings) {
+    actions.add(binding.action);
+  }
+  const childNamespace = node.children.get(resource.resource.LogicalId);
+  if (childNamespace) {
+    actions.add(deriveNamespaceAction(childNamespace));
+  }
+  return deriveAction(actions);
+};
+
+const deriveAction = (
+  actions: Set<BindingAction | CRUD["action"] | DerivedAction>,
+): DerivedAction => {
+  if (actions.size === 0) return "noop";
+  if (actions.has("replace")) return actions.size === 1 ? "replace" : "mixed";
+  if (actions.has("delete")) return actions.size === 1 ? "delete" : "mixed";
+  if (actions.has("create")) return actions.size === 1 ? "create" : "mixed";
+  if (actions.has("update")) return actions.size === 1 ? "update" : "mixed";
+  return "noop";
+};

package/src/Cli/Reporter.ts

@@ -0,0 +1,8 @@
+import * as ServiceMap from "effect/ServiceMap";
+
+export class Reporter extends ServiceMap.Service<
+  Reporter,
+  {
+    report: (event: Event) => void;
+  }
+>()("Reporter") {}

package/src/Cli/components/ApprovePlan.tsx

@@ -0,0 +1,44 @@
+/** @jsxImportSource react */
+import { useState, type JSX } from "react";
+
+import { Box, Text, useApp, useInput } from "ink";
+import type { Plan as AlchemyPlan } from "../../Plan.ts";
+
+import { Plan } from "./Plan.tsx";
+
+export interface ApprovePlanProps {
+  plan: AlchemyPlan;
+  approve: (result: boolean) => void;
+}
+
+export function ApprovePlan(props: ApprovePlanProps): JSX.Element {
+  const { plan, approve } = props;
+  const [selected, setSelected] = useState(0);
+  const { exit } = useApp();
+
+  useInput((_input, key) => {
+    if (key.leftArrow || key.rightArrow) {
+      setSelected((prev) => (prev === 0 ? 1 : 0));
+    } else if (key.return) {
+      approve(selected === 0);
+      exit();
+    }
+  });
+
+  return (
+    <Box flexDirection="column">
+      <Plan plan={plan} />
+      <Box marginTop={1}>
+        <Text>Proceed?</Text>
+      </Box>
+      <Box gap={1}>
+        <Text color={selected === 0 ? "green" : "gray"}>
+          {selected === 0 ? "◉" : "○"} Yes
+        </Text>
+        <Text color={selected === 1 ? "red" : "gray"}>
+          {selected === 1 ? "◉" : "○"} No
+        </Text>
+      </Box>
+    </Box>
+  );
+}

package/src/Cli/components/Plan.tsx

@@ -0,0 +1,148 @@
+/** @jsxImportSource react */
+import { useMemo, type JSX } from "react";
+
+import { Box, Text } from "ink";
+import type { Plan as AlchemyPlan, BindingAction, CRUD } from "../../Plan.ts";
+import {
+  buildNamespaceTree,
+  flattenTree,
+  type DerivedAction,
+} from "../NamespaceTree.ts";
+
+export interface PlanProps {
+  plan: AlchemyPlan;
+}
+export function Plan({ plan }: PlanProps): JSX.Element {
+  const items = useMemo(
+    () =>
+      [
+        ...Object.values(plan.resources),
+        ...Object.values(plan.deletions),
+      ] as CRUD[],
+    [plan],
+  );
+
+  const flatItems = useMemo(() => {
+    const tree = buildNamespaceTree(items);
+    return flattenTree(tree);
+  }, [items]);
+
+  if (items.length === 0) {
+    return <Text color="gray">No changes planned</Text>;
+  }
+
+  const counts = items.reduce((acc, item) => (acc[item.action]++, acc), {
+    create: 0,
+    update: 0,
+    delete: 0,
+    noop: 0,
+    replace: 0,
+  });
+
+  const actions = (["create", "update", "delete", "replace"] as const).filter(
+    (action) => counts[action] > 0,
+  );
+
+  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>
+            </Box>
+          );
+          return i === actions.length - 1
+            ? [box]
+            : [box, <Text key={`${action}-separator`}> | </Text>];
+        })}
+      </Box>
+      <Box flexDirection="column" marginTop={1}>
+        {flatItems.map((item) => {
+          const indent = "  ".repeat(item.depth);
+          const color = getActionColor(item.action);
+          const icon = getActionIcon(item.action);
+          const key = item.path.join("/");
+
+          if (item.type === "namespace") {
+            return (
+              <Box key={key} flexDirection="row">
+                <Text>{indent}</Text>
+                <Box width={2}>
+                  <Text color={color}>{icon} </Text>
+                </Box>
+                <Text color="blueBright">{item.id}</Text>
+              </Box>
+            );
+          }
+
+          if (item.type === "binding") {
+            return (
+              <Box key={key} flexDirection="row">
+                <Text>{indent}</Text>
+                <Box width={2}>
+                  <Text color={color}>{icon} </Text>
+                </Box>
+                <Text color="cyan">{item.bindingSid}</Text>
+              </Box>
+            );
+          }
+
+          // Resource item
+          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.resourceType})</Text>
+              </Box>
+              {item.bindingCount !== undefined && item.bindingCount > 0 && (
+                <Box marginLeft={1}>
+                  <Text color="cyan">({item.bindingCount} bindings)</Text>
+                </Box>
+              )}
+            </Box>
+          );
+        })}
+      </Box>
+    </Box>
+  );
+}
+
+type Color = Parameters<typeof Text>[0]["color"];
+
+type AnyAction = CRUD["action"] | BindingAction | DerivedAction;
+
+const getActionColor = (action: AnyAction): Color =>
+  ({
+    noop: "gray",
+    create: "green",
+    update: "yellow",
+    delete: "red",
+    replace: "magenta",
+    mixed: "cyan",
+  })[action] ?? "gray";
+
+const getActionIcon = (action: AnyAction): string =>
+  ({
+    create: "+",
+    update: "~",
+    delete: "-",
+    noop: "•",
+    replace: "!",
+    mixed: "*",
+  })[action] ?? "?";
+
+const actionColor = (action: CRUD["action"]): Color => getActionColor(action);