alchemy-effect 0.0.0 → 0.2.0

package/lib/type.d.ts

@@ -0,0 +1,3 @@
+export type type<T> = new () => T;
+export declare const type: new <T>() => T;
+//# sourceMappingURL=type.d.ts.map

package/lib/type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type.d.ts","sourceRoot":"","sources":["../src/type.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,IAAI,CAAC,CAAC,IAAI,UAAU,CAAC,CAAC;AAClC,eAAO,MAAM,IAAI,EAAe,KAAK,CAAC,OAAO,CAAC,CAAC"}

package/lib/type.js

@@ -0,0 +1,3 @@
+export const type = class {
+};
+//# sourceMappingURL=type.js.map

package/lib/type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type.js","sourceRoot":"","sources":["../src/type.ts"],"names":[],"mappings":"AACA,MAAM,CAAC,MAAM,IAAI,GAAG;CAA0B,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alchemy-effect",
-  "version": "0.0.0",
+  "version": "0.2.0",
   "license": "Apache-2.0",
   "author": "Sam Goodwin <sam@alchemy.run>",
   "homepage": "https://alchemy.run",
@@ -16,19 +16,128 @@
     "lib",
     "src"
   ],
+  "bin": {
+    "alchemy-effect": "bin/alchemy-effect.js"
+  },
+  "scripts": {
+    "build": "bun bundle && bun pm pack",
+    "bundle": "tsdown",
+    "bundle:watch": "tsdown --watch",
+    "publish:npm": "cp ../README.md . && bun publish && rm README.md"
+  },
   "exports": {
     ".": {
       "bun": "./src/index.ts",
       "import": "./lib/index.js",
       "types": "./src/index.d.ts"
+    },
+    "./aws": {
+      "bun": "./src/aws/index.ts",
+      "import": "./lib/aws/index.js",
+      "types": "./lib/aws/index.d.ts"
+    },
+    "./aws/dynamodb": {
+      "bun": "./src/aws/dynamodb/index.ts",
+      "import": "./lib/aws/dynamodb/index.js",
+      "types": "./lib/aws/dynamodb/index.d.ts"
+    },
+    "./aws/ec2": {
+      "bun": "./src/aws/ec2/index.ts",
+      "import": "./lib/aws/ec2/index.js",
+      "types": "./lib/aws/ec2/index.d.ts"
+    },
+    "./aws/lambda": {
+      "bun": "./src/aws/lambda/index.ts",
+      "import": "./lib/aws/lambda/index.js",
+      "types": "./lib/aws/lambda/index.d.ts"
+    },
+    "./aws/sqs": {
+      "bun": "./src/aws/sqs/index.ts",
+      "import": "./lib/aws/sqs/index.js",
+      "types": "./lib/sqs/aws/index.d.ts"
+    },
+    "./aws/sts": {
+      "bun": "./src/aws/sts.ts",
+      "import": "./lib/aws/sts.js",
+      "types": "./lib/sts.d.ts"
+    },
+    "./aws/iam": {
+      "bun": "./src/aws/iam.ts",
+      "import": "./lib/aws/iam.js",
+      "types": "./lib/iam.d.ts"
+    },
+    "./aws/credentials": {
+      "bun": "./src/aws/credentials.ts",
+      "import": "./lib/aws/credentials.js",
+      "types": "./lib/aws/credentials.d.ts"
+    },
+    "./cli": {
+      "bun": "./src/cli/index.ts",
+      "import": "./lib/cli/index.js",
+      "types": "./lib/cli/index.d.ts"
+    },
+    "./cloudflare": {
+      "bun": "./src/cloudflare/index.ts",
+      "import": "./lib/cloudflare/index.js",
+      "types": "./lib/cloudflare/index.d.ts"
+    },
+    "./cloudflare/live": {
+      "bun": "./src/cloudflare/live.ts",
+      "import": "./lib/cloudflare/live.js",
+      "types": "./lib/cloudflare/live.d.ts"
+    },
+    "./cloudflare/assets": {
+      "bun": "./src/cloudflare/worker/assets.fetch.ts",
+      "import": "./lib/cloudflare/worker/assets.fetch.js",
+      "types": "./lib/cloudflare/worker/assets.fetch.d.ts"
+    },
+    "./cloudflare/worker": {
+      "bun": "./src/cloudflare/worker/index.ts",
+      "import": "./lib/cloudflare/worker/index.js",
+      "types": "./lib/cloudflare/worker/index.d.ts"
+    },
+    "./cloudflare/kv": {
+      "bun": "./src/cloudflare/kv/index.ts",
+      "import": "./lib/cloudflare/kv/index.js",
+      "types": "./lib/cloudflare/kv/index.d.ts"
+    },
+    "./cloudflare/r2": {
+      "bun": "./src/cloudflare/r2/index.ts",
+      "import": "./lib/cloudflare/r2/index.js",
+      "types": "./lib/cloudflare/r2/index.d.ts"
     }
   },
+  "dependencies": {
+    "@aws-sdk/credential-providers": "^3.0.0",
+    "@effect/vitest": "^0.27.0",
+    "@smithy/node-config-provider": "^4.0.0",
+    "@smithy/shared-ini-file-loader": "^4.3.4",
+    "@smithy/types": "^4.8.1",
+    "@types/aws-lambda": "^8.10.152",
+    "aws4fetch": "^1.0.20",
+    "cloudflare": "^5.2.0",
+    "esbuild": "^0.25.12",
+    "fast-xml-parser": "^5.2.5",
+    "ignore": "^7.0.5",
+    "itty-aws": "^0.6.1",
+    "jszip": "^3.10.1",
+    "yaml": "^2.0.0"
+  },
   "devDependencies": {
-    "@effect/platform-node": "^0.98.3",
+    "@clack/prompts": "^0.11.0",
+    "@cloudflare/workers-types": "^4.20250805.0",
     "@effect/platform": "^0.92.1",
+    "@effect/platform-node": "^0.98.3",
+    "@types/aws-lambda": "^8.10.152",
     "@types/bun": "latest",
     "@types/node": "latest",
-    "effect": "^3.18.4"
+    "@types/react": "^19.2.2",
+    "effect": "^3.18.4",
+    "ink": "^6.3.1",
+    "react": "^19.2.0",
+    "react-devtools-core": "^7.0.1",
+    "tsconfig-paths": "^4.2.0",
+    "tsdown": "^0.15.4"
   },
   "peerDependencies": {
     "@effect/platform": "*",
@@ -41,6 +150,9 @@
     },
     "@effect/platform-node": {
       "optional": true
+    },
+    "effect": {
+      "optional": true
     }
   },
   "publishConfig": {

package/src/app.ts

@@ -3,13 +3,12 @@ import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 
-export class App extends Context.Tag("App")<
-  App,
-  {
-    name: string;
-    stage: string;
-  }
->() {}
+export interface AppProps {
+  name: string;
+  stage: string;
+}
+
+export class App extends Context.Tag("App")<App, AppProps>() {}
 
 export class FailedToParseArg extends Data.TaggedError("FailedToParseArg")<{
   message: string;
@@ -41,3 +40,5 @@ export const fromArgs = Layer.effect(
 
 export const app = (input: { name: string; stage: string }) =>
   Layer.succeed(App, App.of(input));
+
+export const make = app;

package/src/apply.ts

@@ -5,8 +5,17 @@ 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 BindNode, type CRUD, type Delete, type Plan } from "./plan.ts";
+import {
+  plan,
+  type BindNode,
+  type Create,
+  type CRUD,
+  type Delete,
+  type Plan,
+  type Update,
+} from "./plan.ts";
 import type { Resource } from "./resource.ts";
+import type { Service } from "./service.ts";
 import { State } from "./state.ts";
 
 export interface PlanStatusSession {
@@ -25,7 +34,34 @@ export class PlanStatusReporter extends Context.Tag("PlanStatusReporter")<
   }
 >() {}
 
-export const apply = <P extends Plan, Err, Req>(
+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)[]>(
+  ...resources: Resources
+) =>
+  applyPlan(
+    plan({
+      phase: "update",
+      resources,
+    }),
+  );
+
+export const applyPlan = <P extends Plan, Err, Req>(
   plan: Effect.Effect<P, Err, Req>,
 ) =>
   plan.pipe(
@@ -49,48 +85,137 @@ export const apply = <P extends Plan, Err, Req>(
             } satisfies PlanStatusSession);
         const { emit, done } = session;
 
-        const applyBindings = Effect.fn(function* (
-          resource: Resource,
-          bindings: BindNode[],
+        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;
-          },
-        ) {
-          return yield* Effect.all(
+          };
+        }) =>
+          Effect.all(
             bindings.map(
               Effect.fn(function* (node) {
-                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`,
-                    );
+                const { resourceId, upstreamAttr, upstreamNode, provider } =
+                  yield* resolveBindingUpstream({ node, resource });
 
-                const attach = provider.attach({
+                const input = {
                   source: {
                     id: resourceId,
                     attr: upstreamAttr,
                     props: upstreamNode.resource.props,
                   },
                   props: node.binding.props,
+                  attr: node.attr,
                   target,
-                });
-                return Effect.isEffect(attach)
-                  ? yield* attach as Effect.Effect<any, never, never>
-                  : attach;
+                } 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,
+        }: {
+          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* 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,
@@ -98,21 +223,25 @@ export const apply = <P extends Plan, Err, Req>(
           Effect.gen(function* () {
             const checkpoint = <Out, Err>(
               effect: Effect.Effect<Out, Err, never>,
-            ) =>
-              effect.pipe(
-                Effect.flatMap((output) =>
-                  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.bindings,
-                    })
-                    .pipe(Effect.map(() => output)),
-                ),
-              );
+            ) => effect.pipe(Effect.flatMap((output) => saveState({ output })));
+
+            const saveState = <Output>({
+              output,
+              bindings = node.bindings,
+            }: {
+              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,
+                })
+                .pipe(Effect.map(() => output));
 
             const id = node.resource.id;
             const resource = node.resource;
@@ -137,71 +266,101 @@ export const apply = <P extends Plan, Err, Req>(
                     status,
                   });
 
-                if (node.action === "noop") {
-                  return (yield* state.get(id))?.output;
-                } else if (node.action === "create") {
-                  let attr: any;
-                  if (node.provider.stub) {
-                    // stub the resource prior to resolving upstream resources or bindings if a stub is available
-                    attr = yield* node.provider.stub({
-                      id,
-                      news: node.news,
-                      session: scopedSession,
-                    });
-                  }
+                const createOrUpdate = Effect.fn(function* ({
+                  node,
+                  attr,
+                  phase,
+                }: {
+                  node: Create<Resource> | Update<Resource>;
+                  attr: any;
+                  phase: "create" | "update";
+                }) {
+                  yield* report(phase === "create" ? "creating" : "updating");
 
-                  const bindings = yield* applyBindings(
+                  let bindingOutputs = yield* attachBindings({
                     resource,
-                    node.bindings,
-                    {
+                    bindings: node.bindings,
+                    target: {
                       id,
                       props: node.news,
                       attr,
                     },
-                  );
+                  });
 
-                  yield* report("creating");
+                  const output: any = yield* (
+                    phase === "create"
+                      ? node.provider.create
+                      : node.provider.update
+                  )({
+                    id,
+                    news: node.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"),
+                    ),
+                  );
 
-                  return yield* node.provider
-                    .create({
-                      id,
-                      news: node.news,
-                      bindings,
-                      session: scopedSession,
-                    })
-                    .pipe(
-                      checkpoint,
-                      Effect.tap(() => report("created")),
-                    );
-                } else if (node.action === "update") {
-                  const bindings = yield* applyBindings(
+                  bindingOutputs = yield* postAttachBindings({
                     resource,
-                    node.bindings,
-                    {
+                    bindings: node.bindings,
+                    bindingOutputs,
+                    target: {
                       id,
                       props: node.news,
-                      attr: node.attributes,
+                      attr,
                     },
-                  );
+                  });
 
-                  yield* report("updating");
+                  yield* saveState({
+                    output,
+                    bindings: node.bindings.map((binding, i) => ({
+                      ...binding,
+                      attr: bindingOutputs[i],
+                    })),
+                  });
 
-                  // const bindings = yield* applyDependencies(node.bindings);
+                  return output;
+                });
 
-                  return yield* node.provider
-                    .update({
+                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,
-                      olds: node.olds,
-                      output: node.output,
-                      bindings,
                       session: scopedSession,
-                    })
-                    .pipe(
-                      checkpoint,
-                      Effect.tap(() => report("updated")),
-                    );
+                    });
+                  }
+
+                  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
@@ -246,15 +405,15 @@ export const apply = <P extends Plan, Err, Req>(
                           id,
                           news: node.news,
                           // TODO(sam): these need to only include attach actions
-                          bindings: yield* applyBindings(
+                          bindings: yield* attachBindings({
                             resource,
-                            node.bindings,
-                            {
+                            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
@@ -265,7 +424,6 @@ export const apply = <P extends Plan, Err, Req>(
                     );
                   });
                   if (!node.deleteFirst) {
-                    const outputs = yield* create;
                     yield* destroy;
                     return outputs;
                   } else {

package/src/aws/account.ts

@@ -0,0 +1,37 @@
+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 STS from "./sts.ts";
+
+export class FailedToGetAccount extends Data.TaggedError(
+  "AWS::Account::FailedToGetAccount",
+)<{
+  message: string;
+  cause: Error;
+}> {}
+
+export type AccountID = string;
+
+export class Account extends Context.Tag("AWS::AccountID")<
+  Account,
+  AccountID
+>() {}
+
+export const fromIdentity = () =>
+  Layer.effect(
+    Account,
+    Effect.gen(function* () {
+      const sts = yield* STS.STSClient;
+      const identity = yield* sts.getCallerIdentity({}).pipe(
+        Effect.catchAll(
+          (err) =>
+            new FailedToGetAccount({
+              message: "Failed to look up account ID",
+              cause: err,
+            }),
+        ),
+      );
+      return identity.Account!;
+    }),
+  );

package/src/aws/arn.ts

@@ -0,0 +1 @@
+export type Arn = string;

package/src/aws/assets.ts

@@ -0,0 +1,8 @@
+import * as Context from "effect/Context";
+
+export class Assets extends Context.Tag("AWS::Assets")<
+  Assets,
+  {
+    bucketName: string;
+  }
+>() {}