feat: use triples in Policy to support overriden tags for bindings

Author: sam-goodwin

@alchemy.run/effect-aws/src/client.ts

@@ -1,4 +1,3 @@
-import type { TagInstance } from "@alchemy.run/effect";
 import type * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
@@ -7,6 +6,8 @@ import type { AWSClientConfig } from "itty-aws";
 import { Credentials } from "./credentials.ts";
 import { Region } from "./region.ts";
 
+export type TagInstance<T> = T extends new (_: never) => infer R ? R : never;
+
 export const createAWSServiceClientLayer =
   <Tag extends Context.Tag<any, any>, Client>(
     tag: Tag,

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

@@ -1,13 +1,10 @@
 import {
-  Binding,
   Provider,
   Runtime,
-  type Capability,
   type RuntimeHandler,
   type RuntimeProps,
 } from "@alchemy.run/effect";
 import type { Context as LambdaContext } from "aws-lambda";
-import * as IAM from "../iam.ts";
 
 export interface FunctionProps<Req = any> extends RuntimeProps<Function, Req> {
   main: string;
@@ -37,21 +34,10 @@ export interface Function<
 > extends Runtime<"AWS.Lambda.Function", Handler, Props> {
   readonly Constructor: Function;
   readonly Provider: FunctionProvider;
-  readonly Binding: FunctionBinding<this["capability"]>;
   readonly Instance: Function<this["handler"], this["props"]>;
 
   readonly attr: FunctionAttr<Extract<this["props"], FunctionProps>>;
 }
 export const Function = Runtime("AWS.Lambda.Function")<Function>();
 
-export interface FunctionBinding<Cap extends Capability>
-  extends Binding<
-    Function,
-    Cap,
-    {
-      env: Record<string, string>;
-      policyStatements: IAM.PolicyStatement[];
-    }
-  > {}
-
 export type FunctionProvider = Provider<Function>;

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

@@ -1,4 +1,3 @@
-import { $ } from "@alchemy.run/effect";
 import type {
   Context as LambdaContext,
   LambdaFunctionURLEvent,
@@ -19,10 +18,5 @@ export const serve =
       ) => Effect.Effect<LambdaFunctionURLResult, never, Req>;
     },
   ) =>
-  <const Props extends Lambda.FunctionProps<Req>>(props: Props) => {
-    const f = Lambda.Function(id, fetch);
-    return f({
-      main: "",
-      bindings: $(),
-    });
-  };
+  <const Props extends Lambda.FunctionProps<Req>>(props: Props) =>
+    Lambda.Function(id, { handle: fetch })(props);

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

@@ -4,6 +4,14 @@ import * as Effect from "effect/Effect";
 import { Function, type FunctionBinding } from "../lambda/index.ts";
 import { Queue } from "./queue.ts";
 
+export type QueueRecord<Data> = Omit<lambda.SQSRecord, "body"> & {
+  body: Data;
+};
+
+export type QueueEvent<Data> = Omit<lambda.SQSEvent, "Records"> & {
+  Records: QueueRecord<Data>[];
+};
+
 export interface Consume<Q> extends Capability<"AWS.SQS.Consume", Q> {}
 
 export const Consume = Function.binding<
@@ -18,14 +26,6 @@ export const Consume = Function.binding<
   ) => FunctionBinding<Consume<Q>>
 >("AWS.SQS.Consume", Queue);
 
-export type QueueRecord<Data> = Omit<lambda.SQSRecord, "body"> & {
-  body: Data;
-};
-
-export type QueueEvent<Data> = Omit<lambda.SQSEvent, "Records"> & {
-  Records: QueueRecord<Data>[];
-};
-
 export const consumeFromLambdaFunction = () =>
   Consume.layer.succeed({
     // oxlint-disable-next-line require-yield

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

@@ -1,7 +1,12 @@
 import * as Effect from "effect/Effect";
 
-import { Policy, type Capability, type Declared } from "@alchemy.run/effect";
-import { Function, type FunctionBinding } from "../lambda/index.ts";
+import {
+  Binding,
+  Policy,
+  type Capability,
+  type Declared,
+} from "@alchemy.run/effect";
+import { Function } from "../lambda/index.ts";
 import { QueueClient } from "./queue.client.ts";
 import { Queue } from "./queue.ts";
 
@@ -22,9 +27,16 @@ export const sendMessage = <Q extends Queue>(
     });
   });
 
-export const SendMessage = Function.binding<
-  <Q extends Queue>(queue: Declared<Q>) => FunctionBinding<SendMessage<Q>>
->("AWS.SQS.SendMessage", Queue);
+// provide a custom tag to uniquely identify your binding implementation of Function<SendMessage<Q>>
+export const SendMessage2 = Binding<
+  <Q extends Queue>(
+    queue: Declared<Q>,
+  ) => Binding<Function, SendMessage<Q>, "Hyperdrive">
+>(Function, Queue, "Hyperdrive");
+
+export const SendMessage = Binding<
+  <Q extends Queue>(queue: Declared<Q>) => Binding<Function, SendMessage<Q>>
+>(Function, Queue, "AWS.SQS.SendMessage");
 
 export const sendMessageFromLambdaFunction = () =>
   SendMessage.layer.succeed({

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

@@ -8,13 +8,34 @@ import { Message, Messages } from "./messages.ts";
 // SQS.SendMessage<Messages>
 // -> FunctionBinding<SQS.SendMessage<Messages>>
 //   -> FunctionBinding<SQS.SendMessage<Queue>>
+//   -> "AWS.Lambda.Function(SQS.SendMessage(AWS.SQS.Queue))"
+
+const ____ = $(SQS.SendMessage(Messages));
+const _____ = $(SQS.SendMessage2(Messages));
+
+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(
       Effect.catchAll(Effect.die),
     );
-    const ___ = SQS.sendMessage(Messages, msg).pipe(
+    yield* SQS.sendMessage(Messages, msg).pipe(
       Effect.catchAll(() => Effect.void),
     );
     return {

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

@@ -1,60 +1,82 @@
-import * as Context from "effect/Context";
-import type * as Effect from "effect/Effect";
+import type { Effect } from "effect/Effect";
+import type { Layer } from "effect/Layer";
 import type { Capability } from "./capability.ts";
-import type { Policy } from "./policy.ts";
 import type { Resource } from "./resource.ts";
 import type { Runtime } from "./runtime.ts";
 
-export type Bindings = ReturnType<typeof Bindings>;
-
-export const Bindings = <S extends any[]>(
-  ...capabilities: S
-): Policy<S[number]> => ({
-  capabilities,
-  and: <C extends Capability[]>(...caps: C): Policy<C[number] | S[number]> =>
-    Bindings(...capabilities, ...caps),
-});
-
-export type $ = typeof $;
-export const $ = Bindings;
-
 export interface BindingProps {
   [key: string]: any;
 }
 
+export const isBinding = (b: any): b is Binding<any, any, any> =>
+  "runtime" in b && "capability" in b && "tag" in b && "output" in b;
+
+export type AnyBinding<F extends Runtime = any> = Binding<F, any, any>;
+
 export interface Binding<
   Run extends Runtime,
   Cap extends Capability = Capability,
-  Output = any,
-> extends Context.TagClass<
-    Runtime.Binding<Run, Cap>,
-    `${Cap["action"]}(${Cap["resource"]["type"]}, ${Run["type"]})`,
-    BindingService<Cap["resource"], Output>
-  > {
+  Tag = Cap["type"],
+> {
   runtime: Run;
   capability: Cap;
-  output: Output;
+  tag: Tag;
 }
 
-export const Binding =
-  <
-    const Runtime extends string,
-    Cap extends Capability,
-    Props extends BindingProps,
-  >(
-    runtime: Runtime,
-    capability: Cap,
-  ) =>
-  <Self>(): Self =>
-    Object.assign(
-      Context.Tag(
-        `${capability.action}(${capability.resource.type}, ${runtime})` as `${Cap["action"]}(${Cap["resource"]["type"]}, ${Runtime})`,
-      )<Self, BindingService<Cap["resource"], Props>>(),
-      {
-        Kind: "Binding",
-        Capability: capability,
+export const Binding = <F extends (resource: any, props?: any) => AnyBinding>(
+  runtime: ReturnType<F>["runtime"],
+  resource: new () => ReturnType<F>["capability"]["resource"],
+  tag: ReturnType<F>["tag"],
+): 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 = (() => {
+    throw new Error(`Should never be called`);
+  }) as unknown as F;
+
+  return Object.assign(handler, {
+    layer: {
+      effect: () => {
+        throw new Error(`Not implemented`);
       },
-    ) as Self;
+      succeed: () => {
+        throw new Error(`Not implemented`);
+      },
+    },
+  });
+};
+
+export interface BindingDeclaration<
+  Run extends Runtime,
+  F extends (target: any, props?: any) => Binding<Run, any>,
+  Tag = ReturnType<F>["tag"],
+> {
+  layer: {
+    effect<Err, Req>(
+      eff: Effect<
+        BindingService<Run["props"], Parameters<F>[0], Parameters<F>[1]>,
+        Err,
+        Req
+      >,
+    ): 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]>>;
+  };
+}
+
+// <Self>(): Self =>
+//   Object.assign(
+//     Context.Tag(
+//       `${capability.action}(${tag}, ${runtime})` as `${Cap["action"]}(${Tag}, ${Runtime})`,
+//     )<Self, BindingService<Cap["resource"], Props>>(),
+//     {
+//       Kind: "Binding",
+//       Capability: capability,
+//     },
+//   ) as Self;
 
 export type BindingService<
   Target = any,

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

@@ -15,4 +15,3 @@ export * from "./provider.ts";
 export * from "./resource.ts";
 export * from "./runtime.ts";
 export * as State from "./state.ts";
-export * from "./tag-instance.ts";

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

@@ -1,11 +1,37 @@
 import * as Effect from "effect/Effect";
+import { type AnyBinding } from "./binding.ts";
 import type { Capability } from "./capability.ts";
+import type { Runtime } from "./runtime.ts";
 
 // A policy is invariant over its allowed actions
-export interface Policy<in out Caps = any> {
-  readonly capabilities: Caps[];
+export interface Policy<
+  in out F extends Runtime,
+  in out Capabilities = any,
+  Tags = unknown,
+> {
+  readonly runtime: F;
+  readonly tags: Tags[];
+  readonly capabilities: Capabilities[];
   /** Add more Capabilities to a Policy */
-  and<C extends any[]>(...caps: C): Policy<C[number] | Caps>;
+  and<B extends AnyBinding[]>(
+    ...bindings: B
+  ): Policy<F, B[number]["capability"] | Capabilities, Tags>;
+}
+
+export type $ = typeof $;
+export const $ = Policy;
+
+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[]) {
+  return {
+    runtime: bindings[0]["runtime"],
+    capabilities: bindings.map((b) => b.capability),
+    tags: bindings.map((b) => b.tag),
+    and: (...b2: AnyBinding[]) => Policy(...bindings, ...b2),
+  };
 }
 
 export namespace Policy {