fix: remove Resource from Binding tag construction and implement layer builders

Author: sam-goodwin

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

@@ -25,7 +25,7 @@ export const QueueEventSource = Binding<
     queue: Q,
     props?: Props,
   ) => Binding<Function, Consume<From<Q>>, Props, "QueueEventSource">
->(Function, Queue, "AWS.SQS.Consume", "QueueEventSource");
+>(Function, "AWS.SQS.Consume", "QueueEventSource");
 
 export const consumeFromLambdaFunction = () =>
   QueueEventSource.provider.succeed({

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

@@ -15,7 +15,7 @@ export interface SendMessage<Q = Queue>
 
 export const SendMessage = Binding<
   <Q extends Queue>(queue: Q) => Binding<Function, SendMessage<To<Q>>>
->(Function, Queue, "AWS.SQS.SendMessage");
+>(Function, "AWS.SQS.SendMessage");
 
 export const sendMessage = <Q extends Queue>(
   queue: Q,

alchemy-effect-cloudflare/src/binding.ts

@@ -1,6 +1,6 @@
 import * as Context from "effect/Context";
 import type { Effect } from "effect/Effect";
-import type { Layer } from "effect/Layer";
+import * as Layer from "effect/Layer";
 import type { Capability } from "./capability.ts";
 import type { Resource } from "./resource.ts";
 import type { Runtime } from "./runtime.ts";
@@ -64,31 +64,29 @@ export interface Bind<
 export const Binding: {
   <F extends (resource: any, props?: any) => AnyBinding & { isCustom: true }>(
     runtime: ReturnType<F>["runtime"],
-    resource: new () => ReturnType<F>["capability"]["resource"],
+    // 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 & { isCustom: false }>(
     runtime: ReturnType<F>["runtime"],
-    resource: new () => ReturnType<F>["capability"]["resource"],
+    // 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) =>
-  Object.assign(
+} = (runtime: any, cap: string, tag?: string) => {
+  const Tag = Context.Tag(`${runtime.type}(${cap}, ${tag ?? cap})`)();
+  return Object.assign(
     () => {
-      throw new Error(`Should never be called`);
+      throw new Error(`Not implemented`);
     },
     {
       provider: {
-        effect: () => {
-          throw new Error(`Not implemented`);
-        },
-        succeed: () => {
-          throw new Error(`Not implemented`);
-        },
+        effect: (eff) => Layer.effect(Tag, eff),
+        succeed: (service) => Layer.succeed(Tag, service),
       },
     } satisfies BindingDeclaration<Runtime, any>,
   );
+};
 
 export interface BindingDeclaration<
   Run extends Runtime,
@@ -103,10 +101,10 @@ export interface BindingDeclaration<
         Err,
         Req
       >,
-    ): Layer<Bind<Run, Cap, Tag>, Err, Req>;
+    ): Layer.Layer<Bind<Run, Cap, Tag>, Err, Req>;
     succeed(
       service: BindingService<Run, Parameters<F>[0], Parameters<F>[1]>,
-    ): Layer<Bind<Run, Cap, Tag>>;
+    ): Layer.Layer<Bind<Run, Cap, Tag>>;
   };
 }
 

alchemy-effect-cloudflare/src/kv.binding.ts

@@ -1,7 +1,6 @@
 import * as Context from "effect/Context";
 import type * as Effect from "effect/Effect";
 import type { ScopedPlanStatusSession } from "./apply.ts";
-import type { Instance } from "./policy.ts";
 import type { Resource } from "./resource.ts";
 import type { Runtime } from "./runtime.ts";
 
@@ -10,9 +9,6 @@ export type Provider<R extends Resource> = Context.TagClass<
   R["type"],
   ProviderService<R>
 >;
-export const Provider = <R extends Resource>(R: R) => {
-  return Context.Tag(R.type)() as Provider<Instance<R>>;
-};
 
 export type Diff =
   | {

alchemy-effect/src/binding.ts

@@ -1,5 +1,6 @@
+import * as Context from "effect/Context";
 import type { Effect } from "effect/Effect";
-import type { Layer } from "effect/Layer";
+import * as Layer from "effect/Layer";
 import type { Provider, ProviderService } from "./provider.ts";
 
 export interface IResource<
@@ -26,8 +27,9 @@ export interface Resource<
 
 export const Resource = <Ctor extends (id: string, props: any) => Resource>(
   type: ReturnType<Ctor>["type"],
-) =>
-  class {
+) => {
+  const Tag = Context.Tag(type)();
+  return class {
     static readonly type = type;
     constructor(id: string, props: any) {
       if (!new.target) {
@@ -42,6 +44,12 @@ export const Resource = <Ctor extends (id: string, props: any) => Resource>(
         };
       }
     }
+    static provider = {
+      effect: (eff: Effect<ProviderService<ReturnType<Ctor>>, any, any>) =>
+        Layer.effect(Tag, eff),
+      succeed: (service: ProviderService<ReturnType<Ctor>>) =>
+        Layer.succeed(Tag, service),
+    };
   } as unknown as Ctor & {
     type: ReturnType<Ctor>["type"];
     new (): ReturnType<Ctor> & {
@@ -50,9 +58,10 @@ export const Resource = <Ctor extends (id: string, props: any) => Resource>(
     provider: {
       effect<Err, Req>(
         eff: Effect<ProviderService<ReturnType<Ctor>>, Err, Req>,
-      ): Layer<Provider<ReturnType<Ctor>>, Err, Req>;
+      ): Layer.Layer<Provider<ReturnType<Ctor>>, Err, Req>;
       succeed(
         service: ProviderService<ReturnType<Ctor>>,
-      ): Layer<Provider<ReturnType<Ctor>>>;
+      ): Layer.Layer<Provider<ReturnType<Ctor>>>;
     };
   };
+};

alchemy-effect/src/provider.ts

@@ -1,7 +1,7 @@
 import type { Types } from "effect";
 import * as Context from "effect/Context";
 import type { Effect } from "effect/Effect";
-import type { Layer } from "effect/Layer";
+import * as Layer from "effect/Layer";
 import type { Capability } from "./capability.ts";
 import type { Policy } from "./policy.ts";
 import type { ProviderService } from "./provider.ts";
@@ -75,10 +75,11 @@ export const Runtime =
     provider: {
       effect<Err, Req>(
         eff: Effect<ProviderService<Self>, Err, Req>,
-      ): Layer<Self, Err, Req>;
-      succeed(service: ProviderService<Self>): Layer<Self>;
+      ): Layer.Layer<Self, Err, Req>;
+      succeed(service: ProviderService<Self>): Layer.Layer<Self>;
     };
   } => {
+    const Tag = Context.Tag(type)();
     const self = Object.assign(
       (
         ...args:
@@ -122,6 +123,12 @@ export const Runtime =
         type: type,
         id: undefined! as string,
         capability: undefined! as Capability[],
+        provider: {
+          effect: (eff: Effect<ProviderService<Self>, any, any>) =>
+            Layer.effect(Tag, eff),
+          succeed: (service: ProviderService<Self>) =>
+            Layer.succeed(Tag, service),
+        },
         toString() {
           return `${this.type}(${this.id}${
             this.capability?.length