feat: capture Capability ID in Binding declaration

Author: sam-goodwin

@alchemy.run/effect-aws/src/sqs/queue.consume.ts

@@ -1,4 +1,4 @@
-import { Binding, Capability, type From } from "@alchemy.run/effect";
+import { Binding, type Capability, type From } from "@alchemy.run/effect";
 import type * as lambda from "aws-lambda";
 import * as Effect from "effect/Effect";
 import { Function } from "../lambda/index.ts";
@@ -14,17 +14,19 @@ export type QueueEvent<Data> = Omit<lambda.SQSEvent, "Records"> & {
 
 export interface Consume<Q = Queue> extends Capability<"AWS.SQS.Consume", Q> {}
 
+export interface QueueEventSourceProps {
+  batchSize?: number;
+  maxBatchingWindow?: number;
+  maxConcurrency?: number;
+  reportBatchItemFailures?: boolean;
+}
+
 export const QueueEventSource = Binding<
-  <Q extends Queue>(
+  <Q extends Queue, const Props extends QueueEventSourceProps>(
     queue: Q,
-    props?: {
-      batchSize?: number;
-      maxBatchingWindow?: number;
-      maxConcurrency?: number;
-      reportBatchItemFailures?: boolean;
-    },
-  ) => Binding<Function, Consume<From<Q>>>
->(Function, Queue, "AWS.SQS.Consume");
+    props?: Props,
+  ) => Binding<Function, Consume<From<Q>>, Props, "QueueEventSource">
+>(Function, Queue, "AWS.SQS.Consume", "QueueEventSource");
 
 export const consumeFromLambdaFunction = () =>
   QueueEventSource.layer.succeed({

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

@@ -5,24 +5,46 @@ import type { Capability } from "./capability.ts";
 import type { Resource } from "./resource.ts";
 import type { Runtime } from "./runtime.ts";
 
+export type SerializedBinding<B extends AnyBinding = AnyBinding> = Omit<
+  B,
+  "resource"
+> & {
+  capability: {
+    resource: {
+      type: string;
+      id: string;
+    };
+  };
+};
+
 export interface BindingProps {
   [key: string]: any;
 }
 
-export const isBinding = (b: any): b is Binding<any, any, any> =>
+export const isBinding = (b: any): b is AnyBinding =>
   "runtime" in b && "capability" in b && "tag" in b && "output" in b;
 
-export type AnyBinding<F extends Runtime = any> = Binding<F, any, any>;
+export type AnyBinding<F extends Runtime = any> = Binding<
+  F,
+  any,
+  any,
+  string,
+  boolean
+>;
 
-export type Binding<
+export interface Binding<
   Run extends Runtime,
   Cap extends Capability = Capability,
+  Props = any,
   Tag extends string = Cap["type"],
-> = {
+  IsCustomTag extends boolean = Cap["type"] extends Tag ? false : true,
+> {
   runtime: Run;
   capability: Cap;
-  tag: Bind<Run, Cap, Tag>;
-};
+  tag: Tag;
+  props: Props;
+  isCustomTag: IsCustomTag;
+}
 
 /** Tag for a Service that can bind a Capability to a Runtime */
 export interface Bind<
@@ -41,19 +63,32 @@ export interface Bind<
   name: Tag;
 }
 
-export const Binding = <F extends (resource: any, props?: any) => AnyBinding>(
-  runtime: ReturnType<F>["runtime"],
-  resource: new () => ReturnType<F>["capability"]["resource"],
-  tag: ReturnType<F>["tag"]["name"],
-  // _tag: ReturnType<F>,
-): F & BindingDeclaration<ReturnType<F>["runtime"], F> => {
-  type Runtime = ReturnType<F>["runtime"];
-  type Tag = ReturnType<F>["tag"];
-  type Resource = new () => ReturnType<F>["capability"]["resource"];
-
-  const handler = (() => {
+export const Binding: {
+  <
+    F extends (
+      resource: any,
+      props?: any,
+    ) => AnyBinding & { isCustomTag: true },
+  >(
+    runtime: ReturnType<F>["runtime"],
+    resource: new () => ReturnType<F>["capability"]["resource"],
+    type: ReturnType<F>["capability"]["type"],
+    tag: ReturnType<F>["tag"],
+  ): F & BindingDeclaration<ReturnType<F>["runtime"], F>;
+  <
+    F extends (
+      resource: any,
+      props?: any,
+    ) => AnyBinding & { isCustomTag: false },
+  >(
+    runtime: ReturnType<F>["runtime"],
+    resource: new () => ReturnType<F>["capability"]["resource"],
+    type: ReturnType<F>["capability"]["type"],
+  ): F & BindingDeclaration<ReturnType<F>["runtime"], F>;
+} = (runtime: any, resource: any, type: string, tag?: string) => {
+  const handler = () => {
     throw new Error(`Should never be called`);
-  }) as unknown as F;
+  };
 
   return Object.assign(handler, {
     layer: {
@@ -69,8 +104,9 @@ export const Binding = <F extends (resource: any, props?: any) => AnyBinding>(
 
 export interface BindingDeclaration<
   Run extends Runtime,
-  F extends (target: any, props?: any) => Binding<Run, any>,
-  Tag = ReturnType<F>["tag"],
+  F extends (target: any, props?: any) => AnyBinding<Run>,
+  Tag extends string = ReturnType<F>["tag"],
+  Cap extends Capability = ReturnType<F>["capability"],
 > {
   layer: {
     effect<Err, Req>(
@@ -79,10 +115,10 @@ export interface BindingDeclaration<
         Err,
         Req
       >,
-    ): Layer<Tag, Err, Req>;
+    ): Layer<Bind<Run, Cap, Tag>, Err, Req>;
     succeed(
       service: BindingService<Run["props"], Parameters<F>[0], Parameters<F>[1]>,
-    ): Layer<Tag>;
+    ): Layer<Bind<Run, Cap, Tag>>;
   };
 }
 

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

@@ -1,13 +1,3 @@
-export type SerializedCapability<B extends Capability = Capability> = Omit<
-  B,
-  "resource"
-> & {
-  resource: {
-    type: string;
-    id: string;
-  };
-};
-
 export interface Capability<
   Type extends string = string,
   Resource = unknown,

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

@@ -1,7 +1,8 @@
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import util from "node:util";
-import type { Capability, SerializedCapability } from "./capability.ts";
+import type { AnyBinding, SerializedBinding } from "./binding.ts";
+import type { Capability } from "./capability.ts";
 import type { Instance } from "./policy.ts";
 import { Provider, type ProviderService } from "./provider.ts";
 import type { Resource } from "./resource.ts";
@@ -23,27 +24,27 @@ export const isBindNode = (node: any): node is BindNode => {
 /**
  * A node in the plan that represents a binding operation acting on a resource.
  */
-export type BindNode<Cap extends Capability = Capability> =
-  | Attach<Cap>
-  | Detach<Cap>
-  | NoopBind<Cap>;
+export type BindNode<B extends AnyBinding = AnyBinding> =
+  | Attach<B>
+  | Detach<B>
+  | NoopBind<B>;
 
-export type Attach<Cap extends Capability = Capability> = {
+export type Attach<B extends AnyBinding = AnyBinding> = {
   action: "attach";
-  capability: Cap;
-  olds?: SerializedCapability<Cap>;
+  binding: B;
+  olds?: SerializedBinding<B>;
   attributes: Capability.Attr<Cap>;
 };
 
-export type Detach<Cap extends Capability = Capability> = {
+export type Detach<B extends AnyBinding = AnyBinding> = {
   action: "detach";
-  capability: Cap;
+  binding: B;
   attributes: Capability.Attr<Cap>;
 };
 
-export type NoopBind<Cap extends Capability = Capability> = {
+export type NoopBind<B extends AnyBinding = AnyBinding> = {
   action: "noop";
-  capability: Cap;
+  binding: B;
   attributes: Capability.Attr<Cap>;
 };
 
@@ -187,7 +188,7 @@ export const plan = <
         (
           resource,
         ): resource is ResourceState & {
-          capabilities: SerializedCapability[];
+          capabilities: SerializedBinding[];
         } => !!resource?.capabilities,
       )
       .flatMap((resource) =>
@@ -441,5 +442,5 @@ const diffCapabilities = (
   return actions;
 };
 
-const isCapabilityDiff = (oldCap: SerializedCapability, newCap: Capability) =>
+const isCapabilityDiff = (oldCap: SerializedBinding, newCap: Capability) =>
   oldCap.action !== newCap.action || oldCap.resource.id !== newCap.resource.id;

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

@@ -1,5 +1,6 @@
+import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
-import { type AnyBinding } from "./binding.ts";
+import { type AnyBinding, type Bind } from "./binding.ts";
 import type { Capability } from "./capability.ts";
 import type { Runtime } from "./runtime.ts";
 
@@ -29,15 +30,25 @@ export interface Policy<
 export type $ = typeof $;
 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"], B[number]["tag"]>;
-export function Policy(...bindings: AnyBinding[]) {
+): 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) => b.tag),
+    tags: bindings.map(
+      (b) => class Tag extends Context.Tag(b.tag as any)<Tag, any>() {},
+    ),
     and: (...b2: AnyBinding[]) => Policy(...bindings, ...b2),
   };
 }

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

@@ -64,9 +64,7 @@ export interface Runtime<
     { handle }: { handle: Handler },
   ): <const Props extends this["props"]>(
     props: Props,
-  ) => Service<ID, this, Handler, Extract<Props, RuntimeProps<this, any>>> & {
-    new (): {};
-  };
+  ) => Service<ID, this, Handler, Extract<Props, RuntimeProps<this, any>>>;
 }
 
 export const Runtime =
@@ -102,7 +100,13 @@ export const Runtime =
                 handler: handle,
                 props,
                 runtime: self,
-              } satisfies Service<string, Self, any, any>,
+                type: type,
+                // TODO(sam): is this right?
+                parent: self,
+              } satisfies Omit<
+                Service<string, Self, any, any>,
+                keyof { new (): {} }
+              >,
             );
         }
       },