alchemy-effect 0.0.0 → 0.2.0

package/src/esbuild.ts

@@ -0,0 +1,98 @@
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Queue from "effect/Queue";
+import type * as Scope from "effect/Scope";
+import type esbuild from "esbuild";
+
+export class ESBuild extends Context.Tag("ESBuild")<
+  ESBuild,
+  {
+    readonly build: <T extends esbuild.BuildOptions>(
+      options: esbuild.SameShape<esbuild.BuildOptions, T>,
+    ) => Effect.Effect<esbuild.BuildResult<T>, ESBuildError>;
+    readonly context: <T extends esbuild.BuildOptions>(
+      options: esbuild.SameShape<esbuild.BuildOptions, T>,
+    ) => Effect.Effect<
+      {
+        queue: Queue.Queue<esbuild.BuildResult<T>>;
+        rebuild: () => Effect.Effect<
+          esbuild.BuildResult<T>,
+          ESBuildError,
+          never
+        >;
+      },
+      ESBuildError,
+      Scope.Scope
+    >;
+  }
+>() {}
+
+export const layer = () =>
+  Layer.effect(
+    ESBuild,
+    Effect.gen(function* () {
+      const esbuild = yield* Effect.promise(() => import("esbuild"));
+      return ESBuild.of({
+        build: Effect.fnUntraced(function* (options) {
+          return yield* Effect.tryPromise({
+            try: () => esbuild.build(options),
+            catch: ESBuildError.map,
+          });
+        }),
+        context: Effect.fnUntraced(function* (options) {
+          const queue = yield* Queue.unbounded<esbuild.BuildResult>();
+          const context = yield* Effect.tryPromise({
+            try: async () =>
+              esbuild.context({
+                ...options,
+                plugins: [
+                  ...(options.plugins ?? []),
+                  {
+                    name: "queue",
+                    setup: (build) => {
+                      build.onEnd((result) => {
+                        Queue.unsafeOffer(queue, result as esbuild.BuildResult);
+                      });
+                    },
+                  },
+                ],
+              }),
+            catch: ESBuildError.map,
+          });
+          yield* Effect.addFinalizer(() =>
+            Effect.promise(() => context.dispose()),
+          );
+          yield* Effect.tryPromise({
+            try: () => context.watch(),
+            catch: ESBuildError.map,
+          });
+          return {
+            queue,
+            rebuild: Effect.fnUntraced(function* () {
+              return yield* Effect.tryPromise({
+                try: (): Promise<esbuild.BuildResult> => context.rebuild(),
+                catch: ESBuildError.map,
+              });
+            }),
+          };
+        }),
+      });
+    }),
+  );
+
+export class ESBuildError extends Data.TaggedError("ESBuildError")<{
+  message: string;
+  errors: esbuild.Message[];
+  messages: esbuild.Message[];
+}> {
+  static map(error: unknown): ESBuildError {
+    const cause = error as esbuild.BuildFailure;
+    return new ESBuildError({
+      message: cause.message,
+      errors: cause.errors,
+      messages: cause.warnings,
+    });
+  }
+}

package/src/index.ts

@@ -14,4 +14,9 @@ export * from "./provider.ts";
 export * from "./resource.ts";
 export * from "./runtime.ts";
 export * from "./service.ts";
+export * from "./type.ts";
+
+// export * as AWS from "./aws/index.ts";
+// export * as CLI from "./cli/index.ts";
+// export * as Cloudflare from "./cloudflare/index.ts";
 export * as State from "./state.ts";

package/src/plan.ts

@@ -1,13 +1,19 @@
+import * as Context from "effect/Context";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
-import type { AnyBinding } from "./binding.ts";
+import { omit } from "effect/Struct";
+import type {
+  AnyBinding,
+  BindingDiffProps,
+  BindingService,
+} 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 Diff, 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";
+import { isService, type IService, type Service } from "./service.ts";
+import { State, StateStoreError, type ResourceState } from "./state.ts";
 
 export type PlanError = never;
 
@@ -26,23 +32,34 @@ export const isBindNode = (node: any): node is BindNode => {
  */
 export type BindNode<B extends AnyBinding = AnyBinding> =
   | Attach<B>
+  | Reattach<B>
   | Detach<B>
   | NoopBind<B>;
 
 export type Attach<B extends AnyBinding = AnyBinding> = {
   action: "attach";
   binding: B;
-  olds?: BindNode;
+  olds: BindNode | undefined;
+  attr: B["attr"] | undefined;
+};
+
+export type Reattach<B extends AnyBinding = AnyBinding> = {
+  action: "reattach";
+  binding: B;
+  olds: BindNode;
+  attr: B["attr"];
 };
 
 export type Detach<B extends AnyBinding = AnyBinding> = {
   action: "detach";
   binding: B;
+  attr: B["attr"] | undefined;
 };
 
 export type NoopBind<B extends AnyBinding = AnyBinding> = {
   action: "noop";
   binding: B;
+  attr: B["attr"];
 };
 
 export const isCRUD = (node: any): node is CRUD => {
@@ -144,19 +161,19 @@ export type Plan = {
 
 export const plan = <
   const Phase extends "update" | "destroy",
-  const Services extends Service[],
+  const Resources extends (Service | Resource)[],
 >({
   phase,
-  services,
+  resources,
 }: {
   phase: Phase;
-  services: Services;
+  resources: Resources;
 }) => {
+  type Services = Extract<Resources[number], IService>[];
   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];
@@ -166,12 +183,17 @@ export const plan = <
       Resource
     >;
   }[ServiceIDs];
-  type Resources = {
+  type ExplicitResources = Resources[number];
+  type ResourceGraph = {
     [ID in ServiceIDs]: Apply<Extract<Instance<ServiceHosts[ID]>, Resource>>;
   } & {
     [ID in UpstreamResources["id"]]: Apply<
       Extract<UpstreamResources, { id: ID }>
     >;
+  } & {
+    [ID in ExplicitResources["id"]]: Apply<
+      Extract<ExplicitResources, { id: ID }>
+    >;
   };
 
   return Effect.gen(function* () {
@@ -190,21 +212,10 @@ export const plan = <
           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],
-        //   ];
-        // }),
+      .flatMap((resource) =>
+        resource.bindings.flatMap(({ binding }) => [
+          [binding.capability.resource.id, binding.capability.resource],
+        ]),
       )
       .reduce(
         (acc, [id, resourceId]) => ({
@@ -214,16 +225,18 @@ export const plan = <
         {} as Record<string, string[]>,
       );
 
-    const resources =
+    const resourceGraph =
       phase === "update"
         ? (Object.fromEntries(
             (yield* Effect.all(
-              services
-                .flatMap((service) => [
-                  ...service.props.bindings.capabilities.map(
-                    (cap: Capability) => cap.resource as Resource,
-                  ),
-                  service,
+              resources
+                .flatMap((resource) => [
+                  ...(isService(resource)
+                    ? resource.props.bindings.capabilities.map(
+                        (cap: Capability) => cap.resource as Resource,
+                      )
+                    : []),
+                  resource,
                 ])
                 .filter(
                   (node, i, arr) =>
@@ -240,16 +253,22 @@ export const plan = <
                     const oldState = yield* state.get(id);
                     const provider = yield* resource.provider.tag;
 
-                    const bindings = diffBindings(
-                      oldState,
-                      isService(node)
-                        ? (
+                    const bindings = isService(node)
+                      ? yield* diffBindings({
+                          oldState,
+                          bindings: (
                             node.props.bindings as unknown as {
                               bindings: AnyBinding[];
                             }
-                          ).bindings
-                        : [],
-                    );
+                          ).bindings,
+                          target: {
+                            id: node.id,
+                            props: node.props,
+                            oldAttr: oldState?.output,
+                            oldProps: oldState?.props,
+                          },
+                        })
+                      : []; // TODO(sam): return undefined instead of empty array
 
                     if (
                       oldState === undefined ||
@@ -264,47 +283,42 @@ export const plan = <
                         // phantom
                         attributes: undefined!,
                       });
-                    } else if (provider.diff) {
-                      const diff = yield* provider.diff({
-                        id,
+                    }
+
+                    const diff = provider.diff
+                      ? yield* provider.diff({
+                          id,
+                          olds: oldState.props,
+                          news,
+                          output: oldState.output,
+                        })
+                      : undefined;
+
+                    if (!diff && arePropsChanged(oldState, resource.props)) {
+                      return Node<Update<Resource>>({
+                        action: "update",
                         olds: oldState.props,
                         news,
                         output: oldState.output,
+                        provider,
+                        resource,
+                        bindings,
+                        // phantom
+                        attributes: undefined!,
                       });
-                      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)) {
+                    } 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 if (diff?.action === "update") {
                       return Node<Update<Resource>>({
                         action: "update",
                         olds: oldState.props,
@@ -335,7 +349,7 @@ export const plan = <
       (yield* Effect.all(
         (yield* state.list()).map(
           Effect.fn(function* (id) {
-            if (id in resources) {
+            if (id in resourceGraph) {
               return;
             }
             const oldState = yield* state.get(id);
@@ -376,7 +390,9 @@ export const plan = <
     );
 
     for (const [resourceId, deletion] of Object.entries(deletions)) {
-      const dependencies = deletion.downstream.filter((d) => d in resources);
+      const dependencies = deletion.downstream.filter(
+        (d) => d in resourceGraph,
+      );
       if (dependencies.length > 0) {
         return yield* Effect.fail(
           new DeleteResourceHasDownstreamDependencies({
@@ -390,17 +406,17 @@ export const plan = <
 
     return {
       phase,
-      resources,
+      resources: resourceGraph,
       deletions,
     } satisfies Plan as Plan;
   }) as Effect.Effect<
     {
       phase: Phase;
       resources: {
-        [ID in keyof Resources]: Resources[ID];
+        [ID in keyof ResourceGraph]: ResourceGraph[ID];
       };
       deletions: {
-        [id in Exclude<string, keyof Resources>]?: Delete<Resource>;
+        [id in Exclude<string, keyof ResourceGraph>]?: Delete<Resource>;
       };
     },
     never,
@@ -416,55 +432,152 @@ class DeleteResourceHasDownstreamDependencies extends Data.TaggedError(
   dependencies: string[];
 }> {}
 
-const compare = <R extends Resource>(
-  oldState: ResourceState | undefined,
-  newState: R["props"],
-) => JSON.stringify(oldState?.props) === JSON.stringify(newState);
-
-const diffBindings = (
+const arePropsChanged = <R extends Resource>(
   oldState: ResourceState | undefined,
-  bindings: AnyBinding[],
+  newProps: R["props"],
 ) => {
-  const actions: BindNode[] = [];
+  return (
+    JSON.stringify(omit(oldState?.props ?? {}, "bindings")) !==
+    JSON.stringify(omit((newProps ?? {}) as any, "bindings"))
+  );
+};
+
+const diffBindings = Effect.fn(function* ({
+  oldState,
+  bindings,
+  target,
+}: {
+  oldState: ResourceState | undefined;
+  bindings: AnyBinding[];
+  target: BindingDiffProps["target"];
+}) {
+  // 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,
+  const diffBinding: (
+    binding: AnyBinding,
+  ) => Effect.Effect<BindNode, StateStoreError, State> = Effect.fn(
+    function* (binding) {
+      const cap = binding.capability;
+      const sid = cap.sid ?? `${cap.action}:${cap.resource.ID}`;
+      // Find potential oldBinding for this sid
+      const oldBinding = oldBindings?.find(
+        ({ binding }) => binding.capability.sid === sid,
+      );
+      if (!oldBinding) {
+        return {
+          action: "attach",
+          binding,
+          attr: undefined,
+          olds: undefined,
+        } satisfies Attach<AnyBinding>;
+      }
+
+      const diff = yield* isBindingDiff({
+        target,
+        oldBinding,
+        newBinding: binding,
       });
-    } else if (isBindingDiff(oldBinding, binding)) {
-      actions.push({
-        action: "attach",
+      // if (diff === false) {
+      // } else if (diff === true) {
+      //   return {
+      //     action: "attach",
+      //     binding,
+      //     olds: oldBinding,
+      //   } satisfies Attach<AnyBinding>;
+      // }
+      if (diff.action === "replace") {
+        return yield* Effect.die(
+          new Error("Replace binding not yet supported"),
+        );
+        // TODO(sam): implement support for replacing bindings
+        // return {
+        //   action: "replace",
+        //   binding,
+        //   olds: oldBinding,
+        // };
+      } else if (diff?.action === "update") {
+        return {
+          action: "reattach",
+          binding,
+          olds: oldBinding,
+          attr: oldBinding.attr,
+        } satisfies Reattach<AnyBinding>;
+      }
+      return {
+        action: "noop",
         binding,
-        olds: oldBinding,
-      });
-    }
+        attr: oldBinding.attr,
+      } satisfies NoopBind<AnyBinding>;
+    },
+  );
+
+  return (yield* Effect.all(bindings.map(diffBinding))).filter(
+    (action): action is BindNode => action !== null,
+  );
+});
+
+const isBindingDiff = Effect.fn(function* ({
+  target,
+  oldBinding: { binding: oldBinding },
+  newBinding,
+}: {
+  // TODO(sam): support binding to other Resources
+  target: BindingDiffProps["target"];
+  oldBinding: BindNode;
+  newBinding: AnyBinding;
+}) {
+  const oldCap = oldBinding.capability;
+  const newCap = newBinding.capability;
+  if (
+    // if the binding provider has changed
+    oldBinding.tag !== newBinding.tag ||
+    // if it points to a totally different resource, we should replace
+    oldCap?.resource?.id !== newCap?.resource?.id ||
+    // if it is a different action
+    oldCap.action !== newCap.action
+  ) {
+    // then we must replace (we need to detach and attach with different bindings or to different resources)
+    return {
+      action: "replace",
+    } satisfies Diff;
   }
-  // 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;
+  const binding = newBinding as AnyBinding & {
+    // smuggled property (because it interacts poorly with inference)
+    Tag: Context.Tag<never, BindingService>;
+  };
+  const provider = yield* binding.Tag;
+  if (provider.diff) {
+    const state = yield* State;
+    const oldState = yield* state.get(oldCap.resource.id);
+    const diff = yield* provider.diff({
+      source: {
+        id: oldCap.resource.id,
+        props: newCap.resource.props,
+        oldProps: oldState?.props,
+        oldAttr: oldState?.output,
+      },
+      props: newBinding.props,
+      attr: oldBinding.attr,
+      target,
+    });
+
+    if (diff?.action === "update" || diff?.action === "replace") {
+      return diff;
+    }
+  }
+  return {
+    action:
+      oldBinding.capability.action !== newBinding.capability.action ||
+      oldBinding.capability?.resource?.id !==
+        newBinding.capability?.resource?.id
+        ? "update"
+        : "noop",
+  } as const;
+});
 // TODO(sam): compare props
 // oldBinding.props !== newBinding.props;

package/src/policy.ts

@@ -1,5 +1,6 @@
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
+import * as S from "effect/Schema";
 import { type AnyBinding, type Bind } from "./binding.ts";
 import type { Capability } from "./capability.ts";
 import type { Runtime } from "./runtime.ts";
@@ -26,7 +27,11 @@ export interface Policy<
   /** Add more Capabilities to a Policy */
   and<B extends AnyBinding[]>(
     ...bindings: B
-  ): Policy<F, B[number]["capability"] | Capabilities, Tags>;
+  ): Policy<
+    F,
+    B[number]["capability"] | Capabilities,
+    BindingTags<B[number]> | Exclude<Tags, unknown>
+  >;
 }
 
 export type $<T> = Instance<T>;
@@ -46,7 +51,7 @@ export function Policy<B extends AnyBinding[]>(
 >;
 export function Policy(...bindings: AnyBinding[]): any {
   return {
-    runtime: bindings[0]["runtime"],
+    runtime: bindings[0]?.["runtime"],
     capabilities: bindings.map((b) => b.capability),
     tags: bindings.map((b) => Context.Tag(b.tag as any)()),
     bindings,
@@ -57,6 +62,54 @@ export function Policy(...bindings: AnyBinding[]): any {
   };
 }
 
+export namespace Policy {
+  export interface AnyOf<in out T> {
+    readonly anyOf: T[];
+  }
+  type Generalize<T> = T extends S.Schema<infer U> ? U : T;
+
+  export const anyOf = <const T>(...anyOf: T[]): AnyOf<Generalize<T>> => ({
+    anyOf: anyOf as Generalize<T>[],
+  });
+
+  export const join = <
+    const Strings extends readonly string[],
+    const Delimiter extends string,
+  >(
+    strings: Strings,
+    delimiter: Delimiter,
+  ) => strings.join(delimiter) as Join<Strings, Delimiter>;
+
+  type ___ = Join<string[], ",">;
+  type Join<
+    T extends readonly string[],
+    Delimiter extends string,
+  > = T extends readonly [infer First extends string]
+    ? First
+    : T extends readonly [
+          infer First extends string,
+          ...infer Rest extends readonly string[],
+        ]
+      ? `${First}${Delimiter}${Join<Rest, Delimiter>}`
+      : T extends string[]
+        ? string
+        : "";
+
+  export type Constraint<T> = Pick<
+    T,
+    {
+      [k in keyof T]: T[k] extends never
+        ? never
+        : T[k] extends AnyOf<never>
+          ? never
+          : k;
+    }[keyof T]
+  >;
+
+  // TODO(sam): one day we might infer policies using a compiler plugin, this is a placeholder
+  export const infer = <T>(): T => undefined!;
+}
+
 /** declare a Policy requiring Capabilities in some context */
 export const declare = <S extends Capability>() =>
   Effect.gen(function* () {}) as Effect.Effect<void, never, S>;