fix: infer return type of Resource.provider.effect

Author: sam-goodwin

alchemy-effect-aws/src/lambda/function.provider.ts

@@ -5,7 +5,7 @@ import { FileSystem } from "@effect/platform";
 import * as Effect from "effect/Effect";
 import * as Schedule from "effect/Schedule";
 
-import { App, DotAlchemy, type ProviderService } from "@alchemy.run/effect";
+import { App, DotAlchemy } from "@alchemy.run/effect";
 
 import type {
   CreateFunctionUrlConfigRequest,
@@ -362,7 +362,7 @@ export const functionProvider = () =>
         }`;
 
       return {
-        type: "AWS.Lambda.Function",
+        // type: "AWS.Lambda.Function",
         read: Effect.fn(function* ({ id, output }) {
           if (output) {
             // example: refresh the function URL from the API
@@ -402,6 +402,7 @@ export const functionProvider = () =>
           return { action: "noop" };
         }),
         create: Effect.fn(function* ({ id, news, bindings, session }) {
+          console.log({ id, news, bindings, session });
           const roleName = createRoleName(id);
           const policyName = createPolicyName(id);
           // const policyArn = `arn:aws:iam::${accountId}:policy/${policyName}`;
@@ -558,6 +559,6 @@ export const functionProvider = () =>
             .pipe(Effect.catchTag("NoSuchEntityException", () => Effect.void));
           return null as any;
         }),
-      } as any satisfies ProviderService<Function>;
+      };
     }),
   );

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

@@ -4,6 +4,8 @@ import type * as IAM from "../iam.ts";
 export type { Context } from "aws-lambda";
 
 export interface FunctionProps<Req = any> {
+  functionName?: string;
+  functionArn?: string;
   main: string;
   handler?: string;
   memory?: number;

alchemy-effect/src/apply.ts

@@ -3,7 +3,6 @@ import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import type { Simplify } from "effect/Types";
 import { PlanReviewer, type PlanRejected } from "./approve.ts";
-import type { Capability } from "./capability.ts";
 import type { ApplyEvent, ApplyStatus } from "./event.ts";
 import { type BindNode, type CRUD, type Delete, type Plan } from "./plan.ts";
 import type { Resource } from "./resource.ts";
@@ -77,28 +76,12 @@ export const apply = <P extends Plan, Err, Req>(
                       status: node.action === "create" ? "created" : "updated",
                       props: node.resource.props,
                       output,
-                      bindings: node.bindings.map((binding) => ({
-                        ...binding,
-                        resource: {
-                          type: binding.binding.capability.resource.type,
-                          id: binding.binding.capability.resource.id,
-                        },
-                      })),
+                      bindings: node.bindings,
                     })
                     .pipe(Effect.map(() => output)),
                 ),
               );
 
-            const hydrate = <A extends BindNode>(bindings: Capability[]) =>
-              node.bindings.map(
-                (binding, i) =>
-                  Object.assign(binding, {
-                    attributes: bindings[i],
-                  }) as A & {
-                    attributes: any;
-                  },
-              );
-
             const id = node.resource.id;
 
             const scopedSession = {
@@ -130,7 +113,7 @@ export const apply = <P extends Plan, Err, Req>(
                     .create({
                       id,
                       news: node.news,
-                      bindings: hydrate(bindings),
+                      bindings,
                       session: scopedSession,
                     })
                     .pipe(
@@ -146,7 +129,7 @@ export const apply = <P extends Plan, Err, Req>(
                       news: node.news,
                       olds: node.olds,
                       output: node.output,
-                      bindings: hydrate(bindings),
+                      bindings,
                       session: scopedSession,
                     })
                     .pipe(
@@ -198,7 +181,7 @@ export const apply = <P extends Plan, Err, Req>(
                           id,
                           news: node.news,
                           // TODO(sam): these need to only include attach actions
-                          bindings: hydrate(yield* apply(node.bindings)),
+                          bindings: yield* apply(node.bindings),
                           session: scopedSession,
                         })
                         // TODO(sam): delete and create will conflict here, we need to extend the state store for replace

alchemy-effect/src/plan.ts

@@ -5,7 +5,7 @@ import type { Capability } from "./capability.ts";
 import type { Phase } from "./phase.ts";
 import type { Instance } from "./policy.ts";
 import { type ProviderService } from "./provider.ts";
-import type { IResource, Resource } from "./resource.ts";
+import type { Resource, ResourceTags } from "./resource.ts";
 import { isService, type Service } from "./service.ts";
 import { State, type ResourceState } from "./state.ts";
 
@@ -59,14 +59,14 @@ export const isCRUD = (node: any): node is CRUD => {
 /**
  * A node in the plan that represents a resource CRUD operation.
  */
-export type CRUD<R extends IResource = IResource> =
+export type CRUD<R extends Resource = Resource> =
   | Create<R>
   | Update<R>
   | Delete<R>
   | Replace<R>
   | NoopUpdate<R>;
 
-export type Apply<R extends IResource = IResource> =
+export type Apply<R extends Resource = Resource> =
   | Create<R>
   | Update<R>
   | Replace<R>
@@ -82,7 +82,7 @@ const Node = <T extends Apply>(node: T) => ({
   },
 });
 
-export type Create<R extends IResource> = {
+export type Create<R extends Resource> = {
   action: "create";
   resource: R;
   news: any;
@@ -91,7 +91,7 @@ export type Create<R extends IResource> = {
   bindings: BindNode[];
 };
 
-export type Update<R extends IResource> = {
+export type Update<R extends Resource> = {
   action: "update";
   resource: R;
   olds: any;
@@ -102,7 +102,7 @@ export type Update<R extends IResource> = {
   bindings: BindNode[];
 };
 
-export type Delete<R extends IResource> = {
+export type Delete<R extends Resource> = {
   action: "delete";
   resource: R;
   olds: any;
@@ -113,14 +113,14 @@ export type Delete<R extends IResource> = {
   downstream: string[];
 };
 
-export type NoopUpdate<R extends IResource> = {
+export type NoopUpdate<R extends Resource> = {
   action: "noop";
   resource: R;
   attributes: R["attr"];
   bindings: BindNode[];
 };
 
-export type Replace<R extends IResource> = {
+export type Replace<R extends Resource> = {
   action: "replace";
   resource: R;
   olds: any;
@@ -222,7 +222,9 @@ export const plan = <
                 .map(
                   Effect.fn(function* (node) {
                     const id = node.id;
-                    const resource = node;
+                    const resource = node as Resource & {
+                      provider: ResourceTags<Resource>;
+                    };
                     const news = isService(node)
                       ? node.runtime.props
                       : resource.props;
@@ -355,7 +357,7 @@ export const plan = <
                     type: oldState.type,
                     attr: oldState.output,
                     props: oldState.props,
-                  } satisfies IResource as Resource,
+                  } as Resource,
                   downstream: downstream[id] ?? [],
                 } satisfies Delete<Resource>,
               ] as const;

alchemy-effect/src/resource.ts

@@ -3,35 +3,28 @@ import type { Effect } from "effect/Effect";
 import * as Layer from "effect/Layer";
 import type { Provider, ProviderService } from "./provider.ts";
 
-export interface IResource<
+export interface Resource<
   Type extends string = string,
   ID extends string = string,
-  Props = any,
-  Attrs = any,
+  Props = unknown,
+  Attrs = unknown,
 > {
   id: ID;
   type: Type;
   props: Props;
   attr: Attrs;
   parent: unknown;
-}
-export interface Resource<
-  Type extends string = string,
-  ID extends string = string,
-  Props = unknown,
-  Attrs = unknown,
-> extends IResource<Type, ID, Props, Attrs> {
   // oxlint-disable-next-line no-misused-new
   new (): Resource<Type, ID, Props, Attrs>;
-  provider: {
-    tag: Context.TagClass<Provider<Resource>, Type, ProviderService<Resource>>;
-    effect<Err, Req>(
-      eff: Effect<ProviderService<Resource>, Err, Req>,
-    ): Layer.Layer<Provider<Resource>, Err, Req>;
-    succeed(
-      service: ProviderService<Resource>,
-    ): Layer.Layer<Provider<Resource>>;
-  };
+}
+
+export interface ResourceTags<R extends Resource> {
+  of<S extends ProviderService<R>>(service: S): S;
+  tag: Context.TagClass<Provider<R>, R["type"], ProviderService<R>>;
+  effect<Err, Req>(
+    eff: Effect<ProviderService<R>, Err, Req>,
+  ): Layer.Layer<Provider<R>, Err, Req>;
+  succeed(service: ProviderService<R>): Layer.Layer<Provider<R>>;
 }
 
 export const Resource = <Ctor extends (id: string, props: any) => Resource>(

alchemy-effect/src/runtime.ts

@@ -5,7 +5,7 @@ import * as Layer from "effect/Layer";
 import type { Capability } from "./capability.ts";
 import type { Policy } from "./policy.ts";
 import type { ProviderService } from "./provider.ts";
-import type { Resource } from "./resource.ts";
+import type { Resource, ResourceTags } from "./resource.ts";
 import type { IService, Service } from "./service.ts";
 
 export type RuntimeHandler<
@@ -52,7 +52,6 @@ export interface Runtime<
   binding: unknown;
   /** @internal phantom */
   capability: unknown;
-  new (): {};
   <
     const ID extends string,
     Inputs extends any[],
@@ -69,15 +68,18 @@ export interface Runtime<
   ) => Service<ID, this, Handler, Props>;
 }
 
+// export interface IRuntime<
+//   Type extends string = string,
+//   Handler = unknown,
+//   Props = unknown,
+// > extends IResource<Type, string, Props, unknown> {
+
+// }
+
 export const Runtime =
   <const Type extends string>(type: Type) =>
   <Self extends Runtime>(): Self & {
-    provider: {
-      effect<Err, Req>(
-        eff: Effect<ProviderService<Self>, Err, Req>,
-      ): Layer.Layer<Self, Err, Req>;
-      succeed(service: ProviderService<Self>): Layer.Layer<Self>;
-    };
+    provider: ResourceTags<Self>;
   } => {
     const Tag = Context.Tag(type)();
     const provider = {

alchemy-effect/src/service.ts

@@ -1,4 +1,4 @@
-import type { IResource, Resource } from "./resource.ts";
+import type { Resource } from "./resource.ts";
 import type { Runtime, RuntimeHandler, RuntimeProps } from "./runtime.ts";
 
 export interface IService<
@@ -7,7 +7,7 @@ export interface IService<
   Handler extends RuntimeHandler = RuntimeHandler,
   Props extends RuntimeProps<F, any> = RuntimeProps<F, any>,
   Attr = (F & { props: Props })["attr"],
-> extends IResource<F["type"], ID, Props, Attr> {
+> extends Resource<F["type"], ID, Props, Attr> {
   kind: "Service";
   type: F["type"];
   id: ID;

example/alchemy.run.ts

@@ -27,7 +27,7 @@ const stack = await plan.pipe(
   Effect.provide(NodeContext.layer),
   Effect.provide(FetchHttpClient.layer),
   Effect.tap((stack) => Effect.log(stack?.Api.functionUrl)),
-  Effect.runPromiseExit,
+  Effect.runPromise,
 );
 
 if (stack) {