alchemy-effect 0.0.0

package/src/plan.ts

@@ -0,0 +1,470 @@
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import type { AnyBinding } from "./binding.ts";
+import type { Capability } from "./capability.ts";
+import type { Phase } from "./phase.ts";
+import type { Instance } from "./policy.ts";
+import { type ProviderService } from "./provider.ts";
+import type { Resource, ResourceTags } from "./resource.ts";
+import { isService, type Service } from "./service.ts";
+import { State, type ResourceState } from "./state.ts";
+
+export type PlanError = never;
+
+export const isBindNode = (node: any): node is BindNode => {
+  return (
+    node &&
+    typeof node === "object" &&
+    (node.action === "attach" ||
+      node.action === "detach" ||
+      node.action === "noop")
+  );
+};
+
+/**
+ * A node in the plan that represents a binding operation acting on a resource.
+ */
+export type BindNode<B extends AnyBinding = AnyBinding> =
+  | Attach<B>
+  | Detach<B>
+  | NoopBind<B>;
+
+export type Attach<B extends AnyBinding = AnyBinding> = {
+  action: "attach";
+  binding: B;
+  olds?: BindNode;
+};
+
+export type Detach<B extends AnyBinding = AnyBinding> = {
+  action: "detach";
+  binding: B;
+};
+
+export type NoopBind<B extends AnyBinding = AnyBinding> = {
+  action: "noop";
+  binding: B;
+};
+
+export const isCRUD = (node: any): node is CRUD => {
+  return (
+    node &&
+    typeof node === "object" &&
+    (node.action === "create" ||
+      node.action === "update" ||
+      node.action === "replace" ||
+      node.action === "noop")
+  );
+};
+
+/**
+ * A node in the plan that represents a resource CRUD operation.
+ */
+export type CRUD<R extends Resource = Resource> =
+  | Create<R>
+  | Update<R>
+  | Delete<R>
+  | Replace<R>
+  | NoopUpdate<R>;
+
+export type Apply<R extends Resource = Resource> =
+  | Create<R>
+  | Update<R>
+  | Replace<R>
+  | NoopUpdate<R>;
+
+const Node = <T extends Apply>(node: T) => ({
+  ...node,
+  toString(): string {
+    return `${this.action.charAt(0).toUpperCase()}${this.action.slice(1)}(${this.resource})`;
+  },
+  [Symbol.toStringTag]() {
+    return this.toString();
+  },
+});
+
+export type Create<R extends Resource> = {
+  action: "create";
+  resource: R;
+  news: any;
+  provider: ProviderService;
+  attributes: R["attr"];
+  bindings: BindNode[];
+};
+
+export type Update<R extends Resource> = {
+  action: "update";
+  resource: R;
+  olds: any;
+  news: any;
+  output: any;
+  provider: ProviderService;
+  attributes: R["attr"];
+  bindings: BindNode[];
+};
+
+export type Delete<R extends Resource> = {
+  action: "delete";
+  resource: R;
+  olds: any;
+  output: any;
+  provider: ProviderService;
+  bindings: BindNode[];
+  attributes: R["attr"];
+  downstream: string[];
+};
+
+export type NoopUpdate<R extends Resource> = {
+  action: "noop";
+  resource: R;
+  attributes: R["attr"];
+  bindings: BindNode[];
+};
+
+export type Replace<R extends Resource> = {
+  action: "replace";
+  resource: R;
+  olds: any;
+  news: any;
+  output: any;
+  provider: ProviderService;
+  bindings: BindNode[];
+  attributes: R["attr"];
+  deleteFirst?: boolean;
+};
+
+export type Plan = {
+  phase: Phase;
+  resources: {
+    [id in string]: CRUD;
+  };
+  deletions: {
+    [id in string]?: Delete<Resource>;
+  };
+};
+
+export const plan = <
+  const Phase extends "update" | "destroy",
+  const Services extends Service[],
+>({
+  phase,
+  services,
+}: {
+  phase: Phase;
+  services: Services;
+}) => {
+  type ServiceIDs = Services[number]["id"];
+  type ServiceHosts = {
+    [ID in ServiceIDs]: Extract<Services[number], Service<Extract<ID, string>>>;
+  };
+
+  type UpstreamTags = {
+    [ID in ServiceIDs]: ServiceHosts[ID]["props"]["bindings"]["tags"][number];
+  }[ServiceIDs];
+  type UpstreamResources = {
+    [ID in ServiceIDs]: Extract<
+      ServiceHosts[ID]["props"]["bindings"]["capabilities"][number]["resource"],
+      Resource
+    >;
+  }[ServiceIDs];
+  type Resources = {
+    [ID in ServiceIDs]: Apply<Extract<Instance<ServiceHosts[ID]>, Resource>>;
+  } & {
+    [ID in UpstreamResources["id"]]: Apply<
+      Extract<UpstreamResources, { id: ID }>
+    >;
+  };
+
+  return Effect.gen(function* () {
+    const state = yield* State;
+
+    const resourceIds = yield* state.list();
+    const resourcesState = yield* Effect.all(
+      resourceIds.map((id) => state.get(id)),
+    );
+    // map of resource ID -> its downstream dependencies (resources that depend on it)
+    const downstream = resourcesState
+      .filter(
+        (
+          resource,
+        ): resource is ResourceState & {
+          bindings: BindNode[];
+        } => !!resource?.bindings,
+      )
+      .flatMap(
+        (resource) =>
+          resource.bindings.flatMap(({ binding }) => [
+            [binding.capability.resource.id, binding.capability.resource],
+          ]),
+        // resource.bindings.flatMap(({ binding }) => {
+        //   const capability: Capability = binding.capability;
+        //   const resource = capability.resource;
+        //   if (!resource) {
+        //     return [];
+        //   }
+        //   return [
+        //     [binding.capability.resource.id, binding.capability.resource],
+        //   ];
+        // }),
+      )
+      .reduce(
+        (acc, [id, resourceId]) => ({
+          ...acc,
+          [id]: [...(acc[id] ?? []), resourceId],
+        }),
+        {} as Record<string, string[]>,
+      );
+
+    const resources =
+      phase === "update"
+        ? (Object.fromEntries(
+            (yield* Effect.all(
+              services
+                .flatMap((service) => [
+                  ...service.props.bindings.capabilities.map(
+                    (cap: Capability) => cap.resource as Resource,
+                  ),
+                  service,
+                ])
+                .filter(
+                  (node, i, arr) =>
+                    arr.findIndex((n) => n.id === node.id) === i,
+                )
+                .map(
+                  Effect.fn(function* (node) {
+                    const id = node.id;
+                    const resource = node as Resource & {
+                      provider: ResourceTags<Resource>;
+                    };
+                    const news = resource.props;
+
+                    const oldState = yield* state.get(id);
+                    const provider = yield* resource.provider.tag;
+
+                    const bindings = diffBindings(
+                      oldState,
+                      isService(node)
+                        ? (
+                            node.props.bindings as unknown as {
+                              bindings: AnyBinding[];
+                            }
+                          ).bindings
+                        : [],
+                    );
+
+                    if (
+                      oldState === undefined ||
+                      oldState.status === "creating"
+                    ) {
+                      return Node<Create<Resource>>({
+                        action: "create",
+                        news,
+                        provider,
+                        resource,
+                        bindings,
+                        // phantom
+                        attributes: undefined!,
+                      });
+                    } else if (provider.diff) {
+                      const diff = yield* provider.diff({
+                        id,
+                        olds: oldState.props,
+                        news,
+                        output: oldState.output,
+                      });
+                      if (diff.action === "noop") {
+                        return Node<NoopUpdate<Resource>>({
+                          action: "noop",
+                          resource,
+                          bindings,
+                          // phantom
+                          attributes: undefined!,
+                        });
+                      } else if (diff.action === "replace") {
+                        return Node<Replace<Resource>>({
+                          action: "replace",
+                          olds: oldState.props,
+                          news,
+                          output: oldState.output,
+                          provider,
+                          resource,
+                          bindings,
+                          // phantom
+                          attributes: undefined!,
+                        });
+                      } else {
+                        return Node<Update<Resource>>({
+                          action: "update",
+                          olds: oldState.props,
+                          news,
+                          output: oldState.output,
+                          provider,
+                          resource,
+                          bindings,
+                          // phantom
+                          attributes: undefined!,
+                        });
+                      }
+                    } else if (compare(oldState, resource.props)) {
+                      return Node<Update<Resource>>({
+                        action: "update",
+                        olds: oldState.props,
+                        news,
+                        output: oldState.output,
+                        provider,
+                        resource,
+                        bindings,
+                        // phantom
+                        attributes: undefined!,
+                      });
+                    } else {
+                      return Node<NoopUpdate<Resource>>({
+                        action: "noop",
+                        resource,
+                        bindings,
+                        // phantom
+                        attributes: undefined!,
+                      });
+                    }
+                  }),
+                ),
+            )).map((update) => [update.resource.id, update]),
+          ) as Plan["resources"])
+        : ({} as Plan["resources"]);
+
+    const deletions = Object.fromEntries(
+      (yield* Effect.all(
+        (yield* state.list()).map(
+          Effect.fn(function* (id) {
+            if (id in resources) {
+              return;
+            }
+            const oldState = yield* state.get(id);
+            const context = yield* Effect.context<never>();
+            if (oldState) {
+              const provider: ProviderService = context.unsafeMap.get(
+                oldState?.type,
+              );
+              if (!provider) {
+                yield* Effect.die(
+                  new Error(`Provider not found for ${oldState?.type}`),
+                );
+              }
+              return [
+                id,
+                {
+                  action: "delete",
+                  olds: oldState.props,
+                  output: oldState.output,
+                  provider,
+                  attributes: oldState?.output,
+                  // TODO(sam): Support Detach Bindings
+                  bindings: [],
+                  resource: {
+                    id: id,
+                    parent: undefined,
+                    type: oldState.type,
+                    attr: oldState.output,
+                    props: oldState.props,
+                  } as Resource,
+                  downstream: downstream[id] ?? [],
+                } satisfies Delete<Resource>,
+              ] as const;
+            }
+          }),
+        ),
+      )).filter((v) => !!v),
+    );
+
+    for (const [resourceId, deletion] of Object.entries(deletions)) {
+      const dependencies = deletion.downstream.filter((d) => d in resources);
+      if (dependencies.length > 0) {
+        return yield* Effect.fail(
+          new DeleteResourceHasDownstreamDependencies({
+            message: `Resource ${resourceId} has downstream dependencies`,
+            resourceId,
+            dependencies,
+          }),
+        );
+      }
+    }
+
+    return {
+      phase,
+      resources,
+      deletions,
+    } satisfies Plan as Plan;
+  }) as Effect.Effect<
+    {
+      phase: Phase;
+      resources: {
+        [ID in keyof Resources]: Resources[ID];
+      };
+      deletions: {
+        [id in Exclude<string, keyof Resources>]?: Delete<Resource>;
+      };
+    },
+    never,
+    UpstreamTags | State
+  >;
+};
+
+class DeleteResourceHasDownstreamDependencies extends Data.TaggedError(
+  "DeleteResourceHasDownstreamDependencies",
+)<{
+  message: string;
+  resourceId: string;
+  dependencies: string[];
+}> {}
+
+const compare = <R extends Resource>(
+  oldState: ResourceState | undefined,
+  newState: R["props"],
+) => JSON.stringify(oldState?.props) === JSON.stringify(newState);
+
+const diffBindings = (
+  oldState: ResourceState | undefined,
+  bindings: AnyBinding[],
+) => {
+  const actions: BindNode[] = [];
+  const oldBindings = oldState?.bindings;
+  const oldSids = new Set(
+    oldBindings?.map(({ binding }) => binding.capability.sid),
+  );
+  for (const binding of bindings) {
+    const cap = binding.capability;
+    const sid = cap.sid ?? `${cap.action}:${cap.resource.ID}`;
+    oldSids.delete(sid);
+
+    const oldBinding = oldBindings?.find(
+      ({ binding }) => binding.capability.sid === sid,
+    );
+    if (!oldBinding) {
+      actions.push({
+        action: "attach",
+        binding,
+      });
+    } else if (isBindingDiff(oldBinding, binding)) {
+      actions.push({
+        action: "attach",
+        binding,
+        olds: oldBinding,
+      });
+    }
+  }
+  // for (const sid of oldSids) {
+  //   actions.push({
+  //     action: "detach",
+  //     cap: oldBindings?.find((binding) => binding.sid === sid)!,
+  //   });
+  // }
+  return actions;
+};
+
+const isBindingDiff = (
+  { binding: oldBinding }: BindNode,
+  newBinding: AnyBinding,
+) =>
+  oldBinding.capability.action !== newBinding.capability.action ||
+  oldBinding.capability?.resource?.id !== newBinding.capability?.resource?.id;
+// TODO(sam): compare props
+// oldBinding.props !== newBinding.props;

package/src/policy.ts

@@ -0,0 +1,77 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import { type AnyBinding, type Bind } from "./binding.ts";
+import type { Capability } from "./capability.ts";
+import type { Runtime } from "./runtime.ts";
+
+/**
+ * A Policy binds a set of Capbilities (e.g SQS.SendMessage, SQS.Consume, etc.) to a
+ * specific Runtime (e.g. AWS Lambda Function, Cloudflare Worker, etc.).
+ *
+ * It brings with it a set of upstream Tags containing the required Provider services
+ * to deploy the infrastructure, e.g. (BindingTag<AWS.Lambda.Function, SendMessage<Queue>>)
+ *
+ * A Policy is invariant over the set of Capabilities to ensure least-privilege.
+ */
+export interface Policy<
+  F extends Runtime,
+  in out Capabilities,
+  Tags = unknown,
+> {
+  readonly runtime: F;
+  readonly tags: Tags[];
+  readonly capabilities: Capabilities[];
+  // phantom property (exists at runtime but not in types)
+  // readonly bindings: AnyBinding[];
+  /** Add more Capabilities to a Policy */
+  and<B extends AnyBinding[]>(
+    ...bindings: B
+  ): Policy<F, B[number]["capability"] | Capabilities, Tags>;
+}
+
+export type $<T> = Instance<T>;
+export const $ = Policy;
+
+type BindingTags<B extends AnyBinding> = B extends any
+  ? Bind<B["runtime"], B["capability"], Extract<B["tag"], string>>
+  : never;
+
+export function Policy<F extends Runtime>(): Policy<F, never, never>;
+export function Policy<B extends AnyBinding[]>(
+  ...capabilities: B
+): Policy<
+  B[number]["runtime"],
+  B[number]["capability"],
+  BindingTags<B[number]>
+>;
+export function Policy(...bindings: AnyBinding[]): any {
+  return {
+    runtime: bindings[0]["runtime"],
+    capabilities: bindings.map((b) => b.capability),
+    tags: bindings.map((b) => Context.Tag(b.tag as any)()),
+    bindings,
+    and: (...b2: AnyBinding[]) => Policy(...bindings, ...b2),
+  } as Policy<any, any, any> & {
+    // add the phantom property
+    bindings: AnyBinding[];
+  };
+}
+
+/** declare a Policy requiring Capabilities in some context */
+export const declare = <S extends Capability>() =>
+  Effect.gen(function* () {}) as Effect.Effect<void, never, S>;
+
+export type Instance<T> = T extends { id: string }
+  ? string extends T["id"]
+    ? T
+    : T extends new (...args: any) => infer I
+      ? I
+      : never
+  : never;
+// syntactic sugar for mapping `typeof Messages` -> Messages, e.g. so it's SQS.SendMessage<Messages> instead of SQS.SendMessage<typeof Messages>
+// e.g. <Q extends SQS.Queue>(queue: Q) => SQS.SendMessage<To<Q>>
+export type From<T> = Instance<T>;
+export type To<T> = Instance<T>;
+export type In<T> = Instance<T>;
+export type Into<T> = Instance<T>;
+export type On<T> = Instance<T>;

package/src/provider.ts

@@ -0,0 +1,74 @@
+import * as Context from "effect/Context";
+import type * as Effect from "effect/Effect";
+import type { ScopedPlanStatusSession } from "./apply.ts";
+import type { Resource } from "./resource.ts";
+import type { Runtime } from "./runtime.ts";
+
+export type Provider<R extends Resource> = Context.TagClass<
+  Provider<R>,
+  R["type"],
+  ProviderService<R>
+>;
+
+export type Diff =
+  | {
+      action: "update" | "noop";
+      deleteFirst?: undefined;
+    }
+  | {
+      action: "replace";
+      deleteFirst?: boolean;
+    };
+
+type BindingData<Res extends Resource> = [Res] extends [Runtime]
+  ? Res["binding"][]
+  : any[];
+
+export interface ProviderService<Res extends Resource = Resource> {
+  // tail();
+  // watch();
+  // replace(): Effect.Effect<void, never, never>;
+
+  // different interface that is persistent, watching, reloads
+  // run?() {}
+  read?(input: {
+    id: string;
+    olds: Res["props"] | undefined;
+    // what is the ARN?
+    output: Res["attr"] | undefined; // current state -> synced state
+    session: ScopedPlanStatusSession;
+    bindings: BindingData<Res>;
+  }): Effect.Effect<Res["attr"] | undefined, any, never>;
+  diff?(input: {
+    id: string;
+    olds: Res["props"];
+    news: Res["props"];
+    output: Res["attr"];
+  }): Effect.Effect<Diff, never, never>;
+  stub?(input: {
+    id: string;
+    news: Res["props"];
+    session: ScopedPlanStatusSession;
+  }): Effect.Effect<Res["attr"], any, never>;
+  create(input: {
+    id: string;
+    news: Res["props"];
+    session: ScopedPlanStatusSession;
+    bindings: BindingData<Res>;
+  }): Effect.Effect<Res["attr"], any, never>;
+  update(input: {
+    id: string;
+    news: Res["props"];
+    olds: Res["props"];
+    output: Res["attr"];
+    session: ScopedPlanStatusSession;
+    bindings: BindingData<Res>;
+  }): Effect.Effect<Res["attr"], any, never>;
+  delete(input: {
+    id: string;
+    olds: Res["props"];
+    output: Res["attr"];
+    session: ScopedPlanStatusSession;
+    bindings: BindingData<Res>;
+  }): Effect.Effect<void, any, never>;
+}

package/src/reporter.ts

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

package/src/resource.ts

@@ -0,0 +1,68 @@
+import * as Context from "effect/Context";
+import type { Effect } from "effect/Effect";
+import * as Layer from "effect/Layer";
+import type { Provider, ProviderService } from "./provider.ts";
+
+export const isResource = (r: any): r is Resource => {
+  return (
+    r && typeof r === "function" && "id" in r && "type" in r && "props" in r
+  );
+};
+
+export interface Resource<
+  Type extends string = string,
+  ID extends string = string,
+  Props = unknown,
+  Attrs = unknown,
+> {
+  id: ID;
+  type: Type;
+  props: Props;
+  attr: Attrs;
+  parent: unknown;
+  // oxlint-disable-next-line no-misused-new
+  new (): Resource<Type, ID, Props, Attrs>;
+}
+
+export interface ResourceTags<R extends Resource> {
+  of<S extends ProviderService<R>>(service: S): S;
+  tag: Context.TagClass<Provider<R>, R["type"], ProviderService<R>>;
+  effect<Err, Req>(
+    eff: Effect<ProviderService<R>, Err, Req>,
+  ): Layer.Layer<Provider<R>, Err, Req>;
+  succeed(service: ProviderService<R>): Layer.Layer<Provider<R>>;
+}
+
+export const Resource = <Ctor extends (id: string, props: any) => Resource>(
+  type: ReturnType<Ctor>["type"],
+) => {
+  const Tag = Context.Tag(type)();
+  const provider = {
+    tag: Tag,
+    effect: <Err, Req>(
+      eff: Effect<ProviderService<ReturnType<Ctor>>, Err, Req>,
+    ) => Layer.effect(Tag, eff),
+    succeed: (service: ProviderService<ReturnType<Ctor>>) =>
+      Layer.succeed(Tag, service),
+  };
+  return Object.assign(
+    function (id: string, props: any) {
+      return class Resource {
+        static readonly id = id;
+        static readonly type = type;
+        static readonly props = props;
+        static readonly provider = provider;
+      };
+    } as unknown as Ctor & {
+      type: ReturnType<Ctor>["type"];
+      new (): ReturnType<Ctor> & {
+        parent: ReturnType<Ctor>;
+      };
+      provider: typeof provider;
+    },
+    {
+      type: type,
+      provider,
+    },
+  );
+};