alchemy-effect 0.2.0 → 0.3.0

package/src/apply.ts

@@ -1,476 +1,464 @@
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
-import * as Option from "effect/Option";
 import type { Simplify } from "effect/Types";
-import { PlanReviewer, type PlanRejected } from "./approve.ts";
 import type { AnyBinding, BindingService } from "./binding.ts";
-import type { ApplyEvent, ApplyStatus } from "./event.ts";
+import type { ApplyStatus } from "./event.ts";
+import * as Output from "./output.ts";
 import {
   plan,
   type BindNode,
   type Create,
   type CRUD,
   type Delete,
-  type Plan,
+  type DerivePlan,
+  type IPlan,
+  type Providers,
   type Update,
 } from "./plan.ts";
-import type { Resource } from "./resource.ts";
-import type { Service } from "./service.ts";
+import type { Instance } from "./policy.ts";
+import type { AnyResource, Resource } from "./resource.ts";
+import type { AnyService } from "./service.ts";
 import { State } from "./state.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 class PlanStatusReporter extends Context.Tag("PlanStatusReporter")<
-  PlanStatusReporter,
+import { App } from "./app.ts";
+import { asEffect } from "./util.ts";
+import { type ScopedPlanStatusSession, CLI } from "./cli/service.ts";
+
+export type ApplyEffect<
+  P extends IPlan,
+  Err = never,
+  Req = never,
+> = Effect.Effect<
   {
-    start(plan: Plan): Effect.Effect<PlanStatusSession, never>;
-  }
->() {}
-
-export const apply: typeof applyPlan &
-  typeof applyResources &
-  typeof applyResourcesPhase = (...args: any[]): any =>
-  Effect.isEffect(args[0])
-    ? applyPlan(args[0] as any)
-    : args.length === 1 && "phase" in args[0]
-      ? applyResourcesPhase(args[0])
-      : applyResources(...args);
-
-export const applyResourcesPhase = <
-  const Phase extends "update" | "destroy",
-  const Resources extends (Service | Resource)[],
->(props: {
-  resources: Resources;
-  phase: Phase;
-}) => applyPlan(plan(props));
-
-export const applyResources = <const Resources extends (Service | Resource)[]>(
+    [k in keyof AppliedPlan<P>]: AppliedPlan<P>[k];
+  },
+  Err,
+  Req
+>;
+
+export type AppliedPlan<P extends IPlan> = {
+  [id in keyof P["resources"]]: P["resources"][id] extends
+    | Delete<Resource>
+    | undefined
+    | never
+    ? never
+    : Simplify<P["resources"][id]["resource"]["attr"]>;
+};
+
+export const apply = <
+  const Resources extends (AnyService | AnyResource)[] = never,
+>(
   ...resources: Resources
-) =>
-  applyPlan(
-    plan({
-      phase: "update",
-      resources,
-    }),
-  );
-
-export const applyPlan = <P extends Plan, Err, Req>(
-  plan: Effect.Effect<P, Err, Req>,
-) =>
-  plan.pipe(
-    Effect.flatMap((plan) =>
-      Effect.gen(function* () {
-        const state = yield* State;
-        const outputs = {} as Record<string, Effect.Effect<any, any>>;
-        const reviewer = yield* Effect.serviceOption(PlanReviewer);
-
-        if (Option.isSome(reviewer)) {
-          yield* reviewer.value.approve(plan);
-        }
-
-        const events = yield* Effect.serviceOption(PlanStatusReporter);
-
-        const session = Option.isSome(events)
-          ? yield* events.value.start(plan)
-          : ({
-              emit: () => Effect.void,
-              done: () => Effect.void,
-            } satisfies PlanStatusSession);
-        const { emit, done } = session;
-
-        const constOrEffect = <T, Err = never, Req = never>(
-          effect: T | Effect.Effect<T>,
-        ): Effect.Effect<T, Err, Req> =>
-          Effect.isEffect(effect) ? effect : Effect.succeed(effect);
-
-        const resolveBindingUpstream = Effect.fn(function* ({
-          node,
-          resource,
-        }: {
-          node: BindNode;
-          resource: Resource;
-        }) {
-          const binding = node.binding as AnyBinding & {
-            // smuggled property (because it interacts poorly with inference)
-            Tag: Context.Tag<never, BindingService>;
-          };
-          const provider = yield* binding.Tag;
-
-          const resourceId: string = node.binding.capability.resource.id;
-          const upstreamNode = plan.resources[resourceId];
-          const upstreamAttr = resource
-            ? yield* apply(upstreamNode)
-            : yield* Effect.dieMessage(`Resource ${resourceId} not found`);
-
-          return {
-            resourceId,
-            upstreamAttr,
-            upstreamNode,
-            provider,
-          };
-        });
-
-        const attachBindings = ({
-          resource,
-          bindings,
-          target,
-        }: {
-          resource: Resource;
-          bindings: BindNode[];
-          target: {
-            id: string;
-            props: any;
-            attr: any;
-          };
-        }) =>
-          Effect.all(
-            bindings.map(
-              Effect.fn(function* (node) {
-                const { resourceId, upstreamAttr, upstreamNode, provider } =
-                  yield* resolveBindingUpstream({ node, resource });
-
-                const input = {
+): ApplyEffect<
+  DerivePlan<Instance<Resources[number]>>,
+  never,
+  State | Providers<Instance<Resources[number]>>
+  // TODO(sam): don't cast to any
+> => plan(...resources).pipe(Effect.flatMap(applyPlan)) as any;
+
+export const applyPlan = <P extends IPlan>(plan: P) =>
+  Effect.gen(function* () {
+    const state = yield* State;
+    // TODO(sam): rename terminology to Stack
+    const app = yield* App;
+    const outputs = {} as Record<string, Effect.Effect<any, any, State>>;
+
+    const cli = yield* CLI;
+
+    const session = yield* cli.startApplySession(plan);
+    const { emit, done } = session;
+
+    const resolveUpstream = Effect.fn(function* (resourceId: string) {
+      const upstreamNode = plan.resources[resourceId];
+      const upstreamAttr = upstreamNode
+        ? yield* apply(upstreamNode)
+        : yield* Effect.dieMessage(`Resource ${resourceId} not found`);
+      return {
+        resourceId,
+        upstreamAttr,
+        upstreamNode,
+      };
+    });
+
+    const resolveBindingUpstream = Effect.fn(function* ({
+      node,
+    }: {
+      node: BindNode;
+      resource: Resource;
+    }) {
+      const binding = node.binding as AnyBinding & {
+        // smuggled property (because it interacts poorly with inference)
+        Tag: Context.Tag<never, BindingService>;
+      };
+      const provider = yield* binding.Tag;
+
+      const resourceId: string = node.binding.capability.resource.id;
+      const { upstreamAttr, upstreamNode } = yield* resolveUpstream(resourceId);
+
+      return {
+        resourceId,
+        upstreamAttr,
+        upstreamNode,
+        provider,
+      };
+    });
+
+    const attachBindings = ({
+      resource,
+      bindings,
+      target,
+    }: {
+      resource: Resource;
+      bindings: BindNode[];
+      target: {
+        id: string;
+        props: any;
+        attr: any;
+      };
+    }) =>
+      Effect.all(
+        bindings.map(
+          Effect.fn(function* (node) {
+            const { resourceId, upstreamAttr, upstreamNode, provider } =
+              yield* resolveBindingUpstream({ node, resource });
+
+            const input = {
+              source: {
+                id: resourceId,
+                attr: upstreamAttr,
+                props: upstreamNode.resource.props,
+              },
+              props: node.binding.props,
+              attr: node.attr,
+              target,
+            } as const;
+            if (node.action === "attach") {
+              return yield* asEffect(provider.attach(input));
+            } else if (node.action === "reattach") {
+              // reattach is optional, we fall back to attach if it's not available
+              return yield* asEffect(
+                (provider.reattach ? provider.reattach : provider.attach)(
+                  input,
+                ),
+              );
+            } else if (node.action === "detach" && provider.detach) {
+              return yield* asEffect(
+                provider.detach({
+                  ...input,
+                  target,
+                }),
+              );
+            }
+            return node.attr;
+          }),
+        ),
+      );
+
+    const postAttachBindings = ({
+      bindings,
+      bindingOutputs,
+      resource,
+      target,
+    }: {
+      bindings: BindNode[];
+      bindingOutputs: any[];
+      resource: Resource;
+      target: {
+        id: string;
+        props: any;
+        attr: any;
+      };
+    }) =>
+      Effect.all(
+        bindings.map(
+          Effect.fn(function* (node, i) {
+            const { resourceId, upstreamAttr, upstreamNode, provider } =
+              yield* resolveBindingUpstream({ node, resource });
+
+            const oldBindingOutput = bindingOutputs[i];
+
+            if (
+              provider.postattach &&
+              (node.action === "attach" || node.action === "reattach")
+            ) {
+              const bindingOutput = yield* asEffect(
+                provider.postattach({
                   source: {
                     id: resourceId,
                     attr: upstreamAttr,
                     props: upstreamNode.resource.props,
                   },
                   props: node.binding.props,
-                  attr: node.attr,
+                  attr: oldBindingOutput,
                   target,
-                } as const;
-                if (node.action === "attach") {
-                  return yield* constOrEffect(provider.attach(input));
-                } else if (node.action === "reattach") {
-                  // reattach is optional, we fall back to attach if it's not available
-                  return yield* constOrEffect(
-                    (provider.reattach ? provider.reattach : provider.attach)(
-                      input,
-                    ),
-                  );
-                } else if (node.action === "detach" && provider.detach) {
-                  return yield* constOrEffect(
-                    provider.detach({
-                      ...input,
-                      target,
-                    }),
-                  );
-                }
-                return node.attr;
-              }),
-            ),
-          );
-
-        const postAttachBindings = ({
-          bindings,
-          bindingOutputs,
-          resource,
-          target,
+                } as const),
+              );
+              return {
+                ...oldBindingOutput,
+                ...bindingOutput,
+              };
+            }
+            return oldBindingOutput;
+          }),
+        ),
+      );
+
+    const apply: (node: CRUD) => Effect.Effect<any, never, never> = (node) =>
+      Effect.gen(function* () {
+        const saveState = <Output>({
+          output,
+          bindings = node.bindings,
+          news,
         }: {
-          bindings: BindNode[];
-          bindingOutputs: any[];
-          resource: Resource;
-          target: {
-            id: string;
-            props: any;
-            attr: any;
-          };
+          output: Output;
+          bindings?: BindNode[];
+          news: any;
         }) =>
-          Effect.all(
-            bindings.map(
-              Effect.fn(function* (node, i) {
-                const { resourceId, upstreamAttr, upstreamNode, provider } =
-                  yield* resolveBindingUpstream({ node, resource });
-
-                const oldBindingOutput = bindingOutputs[i];
-
-                if (
-                  provider.postattach &&
-                  (node.action === "attach" || node.action === "reattach")
-                ) {
-                  const bindingOutput = yield* constOrEffect(
-                    provider.postattach({
-                      source: {
-                        id: resourceId,
-                        attr: upstreamAttr,
-                        props: upstreamNode.resource.props,
-                      },
-                      props: node.binding.props,
-                      attr: oldBindingOutput,
-                      target,
-                    } as const),
-                  );
-                  return {
-                    ...oldBindingOutput,
-                    ...bindingOutput,
-                  };
-                }
-                return oldBindingOutput;
-              }),
-            ),
-          );
-
-        const apply: (node: CRUD) => Effect.Effect<any, never, never> = (
-          node,
-        ) =>
+          state
+            .set({
+              stack: app.name,
+              stage: app.stage,
+              resourceId: node.resource.id,
+              value: {
+                id: node.resource.id,
+                type: node.resource.type,
+                status: node.action === "create" ? "created" : "updated",
+                props: news,
+                output,
+                bindings,
+              },
+            })
+            .pipe(Effect.map(() => output));
+
+        const id = node.resource.id;
+        const resource = node.resource;
+
+        const scopedSession = {
+          ...session,
+          note: (note: string) =>
+            session.emit({
+              id,
+              kind: "annotate",
+              message: note,
+            }),
+        } satisfies ScopedPlanStatusSession;
+
+        return yield* (outputs[id] ??= yield* Effect.cached(
           Effect.gen(function* () {
-            const checkpoint = <Out, Err>(
-              effect: Effect.Effect<Out, Err, never>,
-            ) => effect.pipe(Effect.flatMap((output) => saveState({ output })));
-
-            const saveState = <Output>({
-              output,
-              bindings = node.bindings,
+            const report = (status: ApplyStatus) =>
+              emit({
+                kind: "status-change",
+                id,
+                type: node.resource.type,
+                status,
+              });
+
+            const createOrUpdate = Effect.fn(function* ({
+              node,
+              attr,
+              phase,
             }: {
-              output: Output;
-              bindings?: BindNode[];
-            }) =>
-              state
-                .set(node.resource.id, {
-                  id: node.resource.id,
-                  type: node.resource.type,
-                  status: node.action === "create" ? "created" : "updated",
-                  props: node.resource.props,
-                  output,
-                  bindings,
+              node: Create | Update;
+              attr: any;
+              phase: "create" | "update";
+            }) {
+              const upstream = Object.fromEntries(
+                yield* Effect.all(
+                  Object.entries(Output.resolveUpstream(node.news)).map(
+                    ([id]) =>
+                      resolveUpstream(id).pipe(
+                        Effect.map(({ upstreamAttr }) => [id, upstreamAttr]),
+                      ),
+                  ),
+                ),
+              );
+              const news = yield* Output.evaluate(node.news, upstream);
+
+              yield* report(phase === "create" ? "creating" : "updating");
+
+              let bindingOutputs = yield* attachBindings({
+                resource,
+                bindings: node.bindings,
+                target: {
+                  id,
+                  props: news,
+                  attr,
+                },
+              });
+
+              const output: any = yield* (
+                phase === "create" ? node.provider.create : node.provider.update
+              )({
+                id,
+                news,
+                bindings: bindingOutputs,
+                session: scopedSession,
+                ...(node.action === "update"
+                  ? {
+                      output: node.output,
+                      olds: node.olds,
+                    }
+                  : {}),
+              }).pipe(
+                // TODO(sam): partial checkpoints
+                // checkpoint,
+                Effect.tap(() =>
+                  report(phase === "create" ? "created" : "updated"),
+                ),
+              );
+
+              bindingOutputs = yield* postAttachBindings({
+                resource,
+                bindings: node.bindings,
+                bindingOutputs,
+                target: {
+                  id,
+                  props: news,
+                  attr,
+                },
+              });
+
+              yield* saveState({
+                news,
+                output,
+                bindings: node.bindings.map((binding, i) => ({
+                  ...binding,
+                  attr: bindingOutputs[i],
+                })),
+              });
+
+              return output;
+            });
+
+            if (node.action === "noop") {
+              return (yield* state.get({
+                stack: app.name,
+                stage: app.stage,
+                resourceId: id,
+              }))?.output;
+            } else if (node.action === "create") {
+              let attr: any;
+              if (node.provider.precreate) {
+                yield* Effect.logDebug("precreate", id);
+                // stub the resource prior to resolving upstream resources or bindings if a stub is available
+                attr = yield* node.provider.precreate({
+                  id,
+                  news: node.news,
+                  session: scopedSession,
+                });
+              }
+
+              yield* Effect.logDebug("create", id);
+              return yield* createOrUpdate({
+                node,
+                attr,
+                phase: "create",
+              });
+            } else if (node.action === "update") {
+              yield* Effect.logDebug("update", id);
+              return yield* createOrUpdate({
+                node,
+                attr: node.attributes,
+                phase: "update",
+              });
+            } else if (node.action === "delete") {
+              yield* Effect.logDebug("delete", id);
+              yield* Effect.all(
+                node.downstream.map((dep) =>
+                  dep in plan.resources
+                    ? apply(plan.resources[dep] as any)
+                    : Effect.void,
+                ),
+              );
+              yield* report("deleting");
+
+              return yield* node.provider
+                .delete({
+                  id,
+                  olds: node.olds,
+                  output: node.output,
+                  session: scopedSession,
+                  bindings: [],
                 })
-                .pipe(Effect.map(() => output));
-
-            const id = node.resource.id;
-            const resource = node.resource;
-
-            const scopedSession = {
-              ...session,
-              note: (note: string) =>
-                session.emit({
+                .pipe(
+                  Effect.flatMap(() =>
+                    state.delete({
+                      stack: app.name,
+                      stage: app.stage,
+                      resourceId: id,
+                    }),
+                  ),
+                  Effect.tap(() => report("deleted")),
+                );
+            } else if (node.action === "replace") {
+              const destroy = Effect.gen(function* () {
+                yield* report("deleting");
+                return yield* node.provider.delete({
                   id,
-                  kind: "annotate",
-                  message: note,
-                }),
-            } satisfies ScopedPlanStatusSession;
-
-            return yield* (outputs[id] ??= yield* Effect.cached(
-              Effect.gen(function* () {
-                const report = (status: ApplyStatus) =>
-                  emit({
-                    kind: "status-change",
-                    id,
-                    type: node.resource.type,
-                    status,
-                  });
+                  olds: node.olds,
+                  output: node.output,
+                  session: scopedSession,
+                  bindings: [],
+                });
+              });
+              const create = Effect.gen(function* () {
+                yield* report("creating");
 
-                const createOrUpdate = Effect.fn(function* ({
-                  node,
-                  attr,
-                  phase,
-                }: {
-                  node: Create<Resource> | Update<Resource>;
-                  attr: any;
-                  phase: "create" | "update";
-                }) {
-                  yield* report(phase === "create" ? "creating" : "updating");
-
-                  let bindingOutputs = yield* attachBindings({
-                    resource,
-                    bindings: node.bindings,
-                    target: {
-                      id,
-                      props: node.news,
-                      attr,
-                    },
-                  });
-
-                  const output: any = yield* (
-                    phase === "create"
-                      ? node.provider.create
-                      : node.provider.update
-                  )({
+                // TODO(sam): delete and create will conflict here, we need to extend the state store for replace
+                return yield* node.provider
+                  .create({
                     id,
                     news: node.news,
-                    bindings: bindingOutputs,
+                    // TODO(sam): these need to only include attach actions
+                    bindings: yield* attachBindings({
+                      resource,
+                      bindings: node.bindings,
+                      target: {
+                        id,
+                        // TODO(sam): resolve the news
+                        props: node.news,
+                        attr: node.attributes,
+                      },
+                    }),
                     session: scopedSession,
-                    ...(node.action === "update"
-                      ? {
-                          output: node.output,
-                          olds: node.olds,
-                        }
-                      : {}),
-                  }).pipe(
-                    // TODO(sam): partial checkpoints
-                    // checkpoint,
-                    Effect.tap(() =>
-                      report(phase === "create" ? "created" : "updated"),
-                    ),
-                  );
-
-                  bindingOutputs = yield* postAttachBindings({
-                    resource,
-                    bindings: node.bindings,
-                    bindingOutputs,
-                    target: {
-                      id,
-                      props: node.news,
-                      attr,
-                    },
-                  });
-
-                  yield* saveState({
-                    output,
-                    bindings: node.bindings.map((binding, i) => ({
-                      ...binding,
-                      attr: bindingOutputs[i],
-                    })),
-                  });
-
-                  return output;
-                });
-
-                if (node.action === "noop") {
-                  return (yield* state.get(id))?.output;
-                } else if (node.action === "create") {
-                  let attr: any;
-                  if (node.provider.precreate) {
-                    yield* Effect.logDebug("precreate", id);
-                    // stub the resource prior to resolving upstream resources or bindings if a stub is available
-                    attr = yield* node.provider.precreate({
-                      id,
-                      news: node.news,
-                      session: scopedSession,
-                    });
-                  }
-
-                  yield* Effect.logDebug("create", id);
-                  return yield* createOrUpdate({
-                    node,
-                    attr,
-                    phase: "create",
-                  });
-                } else if (node.action === "update") {
-                  yield* Effect.logDebug("update", id);
-                  return yield* createOrUpdate({
-                    node,
-                    attr: node.attributes,
-                    phase: "update",
-                  });
-                } else if (node.action === "delete") {
-                  yield* Effect.logDebug("delete", id);
-                  yield* Effect.all(
-                    node.downstream.map((dep) =>
-                      dep in plan.resources
-                        ? apply(
-                            plan.resources[
-                              dep
-                            ] as P["resources"][keyof P["resources"]],
-                          )
-                        : Effect.void,
+                  })
+                  .pipe(
+                    Effect.tap((output) =>
+                      saveState({ news: node.news, output }),
                     ),
                   );
-                  yield* report("deleting");
-
-                  return yield* node.provider
-                    .delete({
-                      id,
-                      olds: node.olds,
-                      output: node.output,
-                      session: scopedSession,
-                      bindings: [],
-                    })
-                    .pipe(
-                      Effect.flatMap(() => state.delete(id)),
-                      Effect.tap(() => report("deleted")),
-                    );
-                } else if (node.action === "replace") {
-                  const destroy = Effect.gen(function* () {
-                    yield* report("deleting");
-                    return yield* node.provider.delete({
-                      id,
-                      olds: node.olds,
-                      output: node.output,
-                      session: scopedSession,
-                      bindings: [],
-                    });
-                  });
-                  const create = Effect.gen(function* () {
-                    yield* report("creating");
-                    return yield* (
-                      node.provider
-                        .create({
-                          id,
-                          news: node.news,
-                          // TODO(sam): these need to only include attach actions
-                          bindings: yield* attachBindings({
-                            resource,
-                            bindings: node.bindings,
-                            target: {
-                              id,
-                              props: node.news,
-                              attr: node.attributes,
-                            },
-                          }),
-                          session: scopedSession,
-                        })
-                        // TODO(sam): delete and create will conflict here, we need to extend the state store for replace
-                        .pipe(
-                          checkpoint,
-                          Effect.tap(() => report("created")),
-                        )
-                    );
-                  });
-                  if (!node.deleteFirst) {
-                    yield* destroy;
-                    return outputs;
-                  } else {
-                    yield* destroy;
-                    return yield* create;
-                  }
-                }
-              }),
-            ));
-          }) as Effect.Effect<any, never, never>;
-
-        const nodes = [
-          ...Object.entries(plan.resources),
-          ...Object.entries(plan.deletions),
-        ];
-
-        const resources: any = Object.fromEntries(
-          yield* Effect.all(
-            nodes.map(
-              Effect.fn(function* ([id, node]) {
-                return [id, yield* apply(node as CRUD)];
-              }),
-            ),
-          ),
-        );
-        yield* done();
-        if (Object.keys(plan.resources).length === 0) {
-          // all resources are deleted, return undefined
-          return undefined;
-        }
-        return resources;
-      }),
-    ),
-  ) as Effect.Effect<
-    "update" extends P["phase"]
-      ?
-          | {
-              [id in keyof P["resources"]]: P["resources"][id] extends
-                | Delete<Resource>
-                | undefined
-                | never
-                ? never
-                : Simplify<P["resources"][id]["resource"]["attr"]>;
+              });
+              if (!node.deleteFirst) {
+                yield* destroy;
+                return outputs;
+              } else {
+                yield* destroy;
+                return yield* create;
+              }
             }
-          // union distribution isn't happening, so we gotta add this additional void here just in case
-          | ("destroy" extends P["phase"] ? void : never)
-      : void,
-    Err | PlanRejected,
-    Req
-  >;
+          }),
+        ));
+      }) as Effect.Effect<any, never, never>;
+
+    const nodes = [
+      ...Object.entries(plan.resources),
+      ...Object.entries(plan.deletions),
+    ];
+
+    const resources: any = Object.fromEntries(
+      yield* Effect.all(
+        nodes.map(
+          Effect.fn(function* ([id, node]) {
+            return [id, yield* apply(node as CRUD)];
+          }),
+        ),
+      ),
+    );
+    yield* done();
+    if (Object.keys(plan.resources).length === 0) {
+      // all resources are deleted, return undefined
+      return undefined;
+    }
+    return resources as {
+      [k in keyof AppliedPlan<P>]: AppliedPlan<P>[k];
+    };
+  });