fix: re-work simpler types for plan and apply

Author: sam-goodwin

@alchemy.run/effect-aws/src/lambda/function.ts

@@ -1,12 +1,5 @@
-import {
-  Capability,
-  Policy,
-  Provider,
-  Runtime,
-  type RuntimeHandler,
-} from "@alchemy.run/effect";
+import { Capability, Policy, Runtime } from "@alchemy.run/effect";
 
-import type { Context } from "aws-lambda";
 export type { Context } from "aws-lambda";
 
 export interface FunctionProps<Req = any> {
@@ -30,17 +23,7 @@ export type FunctionAttr<Props extends FunctionProps = FunctionProps> = {
   };
 };
 
-export interface Function<
-  Handler extends
-    | RuntimeHandler<[event: any, context: Context]>
-    | unknown = unknown,
-  Props extends FunctionProps<RuntimeHandler.Caps<Handler>> | unknown = unknown,
-> extends Runtime<"AWS.Lambda.Function", Handler, Props> {
-  readonly Provider: FunctionProvider;
-  readonly Instance: Function<this["handler"], this["props"]>;
-
+export interface Function extends Runtime<"AWS.Lambda.Function"> {
   readonly attr: FunctionAttr<Extract<this["props"], FunctionProps>>;
 }
 export const Function = Runtime("AWS.Lambda.Function")<Function>();
-
-export type FunctionProvider = Provider<Function>;

@alchemy.run/effect-aws/src/lambda/serve.ts

@@ -23,4 +23,7 @@ export const serve =
     },
   ) =>
   <const Props extends Lambda.FunctionProps<Req>>(props: Props) =>
-    Lambda.Function(id, { handle: fetch })(props);
+    Lambda.Function(id, { handle: fetch })({
+      ...props,
+      url: true,
+    });

@alchemy.run/effect-example/alchemy.run.ts

@@ -4,12 +4,12 @@ import * as AlchemyCLI from "@alchemy.run/effect-cli";
 import { FetchHttpClient } from "@effect/platform";
 import { NodeContext } from "@effect/platform-node";
 import * as Effect from "effect/Effect";
-import { MyMonitor } from "./src/component.ts";
-import { Api, Consumer } from "./src/index.ts";
+import { Api } from "./src/index.ts";
 
 const plan = Alchemy.plan({
-  phase: process.argv.includes("--destroy") ? "destroy" : "update",
-  resources: [Api, Consumer, MyMonitor],
+  // phase: process.argv.includes("--destroy") ? "destroy" : "update",
+  phase: "update",
+  services: [Api],
 });
 
 const stack = await plan.pipe(
@@ -25,3 +25,7 @@ const stack = await plan.pipe(
   Effect.tap((stack) => Effect.log(stack?.Api.functionUrl)),
   Effect.runPromise,
 );
+
+if (stack) {
+  // Effect.log(stack?.Api.functionUrl);
+}

@alchemy.run/effect-example/src/api.ts

@@ -5,23 +5,6 @@ import * as Effect from "effect/Effect";
 import * as S from "effect/Schema";
 import { Message, Messages } from "./messages.ts";
 
-const ___ = Lambda.serve("Api", {
-  fetch: Effect.fn(function* (event) {
-    const msg = yield* S.validate(Message)(event.body).pipe(
-      Effect.catchAll(Effect.die),
-    );
-    yield* SQS.sendMessage(Messages, msg).pipe(
-      Effect.catchAll(() => Effect.void),
-    );
-    return {
-      body: JSON.stringify(null),
-    };
-  }),
-})({
-  main: import.meta.filename,
-  bindings: $(SQS.SendMessage(Messages)),
-});
-
 export class Api extends Lambda.serve("Api", {
   fetch: Effect.fn(function* (event) {
     const msg = yield* S.validate(Message)(event.body).pipe(

@alchemy.run/effect-example/src/messages.ts

@@ -6,7 +6,7 @@ export class Message extends S.Class<Message>("Message")({
   value: S.String,
 }) {}
 
-export class Messages extends SQS.Queue("messages", {
+export class Messages extends SQS.Queue("Messages", {
   fifo: true,
   schema: Message,
 }) {}

@alchemy.run/effect/src/bind.ts

@@ -21,19 +21,20 @@ export type Binding<
 > = {
   runtime: Run;
   capability: Cap;
-  tag: BindingTag<Run, Cap, Tag>;
+  tag: Bind<Run, Cap, Tag>;
 };
 
-export interface BindingTag<
-  Run extends Runtime,
+/** Tag for a Service that can bind a Capability to a Runtime */
+export interface Bind<
+  F extends Runtime,
   Cap extends Capability,
   Tag extends string,
 > extends Context.Tag<
-    `${Run["type"]}(${Cap["type"]}, ${Tag})`,
+    `${F["type"]}(${Cap["type"]}, ${Tag})`,
     BindingService<
-      Run,
+      F,
       Extract<Extract<Cap["resource"], Resource>["parent"], Resource>,
-      Run["props"]
+      F["props"]
     >
   > {
   /** @internal phantom */
@@ -81,7 +82,7 @@ export interface BindingDeclaration<
     ): Layer<Tag, Err, Req>;
     succeed(
       service: BindingService<Run["props"], Parameters<F>[0], Parameters<F>[1]>,
-    ): Layer<BindingService<Run["props"], Parameters<F>[0], Parameters<F>[1]>>;
+    ): Layer<Tag>;
   };
 }
 

@alchemy.run/effect/src/binding.ts

@@ -1,7 +1,6 @@
 export * from "./app.ts";
 export * from "./apply.ts";
 export * from "./approve.ts";
-export * from "./bind.ts";
 export * from "./binding.ts";
 export * from "./capability.ts";
 export * from "./destroy.ts";
@@ -13,4 +12,5 @@ export * from "./policy.ts";
 export * from "./provider.ts";
 export * from "./resource.ts";
 export * from "./runtime.ts";
+export * from "./service.ts";
 export * as State from "./state.ts";

@alchemy.run/effect/src/index.ts

@@ -1,12 +1,11 @@
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import util from "node:util";
-import { isBound, type Bound } from "./bind.ts";
 import type { Capability, SerializedCapability } from "./capability.ts";
-import type { Phase } from "./phase.ts";
+import type { Instance } from "./policy.ts";
 import { Provider, type ProviderService } from "./provider.ts";
 import type { Resource } from "./resource.ts";
-import type { Runtime } from "./runtime.ts";
+import type { Service } from "./service.ts";
 import { State, type ResourceState } from "./state.ts";
 
 export type PlanError = never;
@@ -139,65 +138,42 @@ export type Replace<R extends Resource> = {
   deleteFirst?: boolean;
 };
 
-type PlanNode = Bound<any> | Resource;
-type PlanGraph = {
-  [id in string]: PlanNode;
-};
-type PlanGraphEffect = Effect.Effect<PlanGraph, never, unknown>;
-
-type ApplyAll<
-  Subgraphs extends PlanGraphEffect[],
-  Accum extends Record<string, CRUD> = {},
-> = Subgraphs extends [
-  infer Head extends PlanGraphEffect,
-  ...infer Tail extends PlanGraphEffect[],
-]
-  ? ApplyAll<
-      Tail,
-      Accum & {
-        [id in keyof Effect.Effect.Success<Head>]: _Apply<
-          Extract<Effect.Effect.Success<Head>[id], PlanNode>
-        >;
-      }
-    >
-  : Accum;
-
-type _Apply<Item extends PlanNode> =
-  Item extends Bound<infer Run extends Runtime<string, any, any>>
-    ? Apply<Run>
-    : Item extends Resource
-      ? Apply<Item>
-      : never;
-
-type DerivePlan<
-  P extends Phase = Phase,
-  Resources extends PlanGraphEffect[] = PlanGraphEffect[],
-> = P extends "update"
-  ?
-      | {
-          [k in keyof ApplyAll<Resources>]: ApplyAll<Resources>[k];
-        }
-      | {
-          [k in Exclude<string, keyof ApplyAll<Resources>>]: Delete<Resource>;
-        }
-  : {
-      [k in Exclude<string, keyof ApplyAll<Resources>>]: Delete<Resource>;
-    };
-
 export type Plan = {
   [id in string]: CRUD;
 };
 
 export const plan = <
   const Phase extends "update" | "destroy",
-  const Resources extends PlanGraphEffect[],
+  const Services extends Service[],
 >({
   phase,
-  resources,
+  services,
 }: {
   phase: Phase;
-  resources: Resources;
+  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 Graph = {
+    [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;
 
@@ -228,7 +204,7 @@ export const plan = <
     const updates = (
       phase === "update"
         ? yield* Effect.all(
-            resources.map((resource) =>
+            services.map((resource) =>
               Effect.flatMap(
                 resource,
                 Effect.fn(function* (subgraph: {
@@ -405,9 +381,11 @@ export const plan = <
       {} as any,
     );
   }) as Effect.Effect<
-    DerivePlan<Phase, Resources>,
+    {
+      [ID in keyof Graph]: Graph[ID];
+    },
     never,
-    Effect.Effect.Context<Resources[number]> | State
+    UpstreamTags | State
   >;
 };
 

@alchemy.run/effect/src/plan.ts

@@ -46,7 +46,7 @@ export function Policy(...bindings: AnyBinding[]) {
 export const declare = <S extends Capability>() =>
   Effect.gen(function* () {}) as Effect.Effect<void, never, S>;
 
-type Instance<T> = { id: string } extends T
+export type Instance<T> = { id: string } extends T
   ? T
   : T extends new (...args: any) => infer I
     ? I