alchemy 2.0.0-beta.1 → 2.0.0-beta.2

package/src/Platform.ts

@@ -13,7 +13,7 @@ import {
 } from "./ExecutionContext.ts";
 import type { HttpEffect } from "./Http.ts";
 import type { InputProps } from "./Input.ts";
-import type { Provider } from "./Provider.ts";
+import type { Provider, ProviderCollectionLike } from "./Provider.ts";
 import { Resource, type ResourceLike } from "./Resource.ts";
 import { Self } from "./Self.ts";
 import type { Stack, StackServices } from "./Stack.ts";
@@ -42,6 +42,7 @@ export type PlatformServices =
   | HttpClient
   | PolicyLike
   | Provider<any>
+  | ProviderCollectionLike
   | Scope
   | Stack
   | StackServices
@@ -70,14 +71,14 @@ export interface Platform<
     ): Effect.Effect<
       Resource & Rpc<Self>,
       never,
-      Self | Provider<Resource> | PropsReq
+      Self | Resource["Providers"] | PropsReq
     > & {
       make<InitReq = never>(
         impl: Effect.Effect<Shape, never, InitReq>,
       ): Layer.Layer<
         Self,
         never,
-        | Provider<Resource>
+        | Resource["Providers"]
         | Exclude<PropsReq | InitReq, Services | PlatformServices>
       >;
       new (_: never): MakeShape<Shape, BaseShape>;
@@ -98,7 +99,7 @@ export interface Platform<
     ): Effect.Effect<
       Resource & Rpc<Self>,
       never,
-      | Provider<Resource>
+      | Resource["Providers"]
       | PropsReq
       | Exclude<InitReq, Services | PlatformServices>
     > & {
@@ -112,14 +113,14 @@ export interface Platform<
     ): Effect.Effect<
       Resource & Rpc<Self>,
       never,
-      Provider<Resource> | PropsReq
+      Resource["Providers"] | PropsReq
     > & {
       make<InitReq extends Services | PlatformServices = never>(
         impl: Effect.Effect<Shape, never, InitReq>,
       ): Layer.Layer<
         Self,
         never,
-        | Provider<Resource>
+        | Resource["Providers"]
         | Exclude<PropsReq | InitReq, Services | PlatformServices>
       >;
       new (_: never): MakeShape<Shape, BaseShape>;
@@ -128,7 +129,7 @@ export interface Platform<
       ) => Effect.Effect<
         Resource & Rpc<Self>,
         never,
-        | Provider<Resource>
+        | Resource["Providers"]
         | PropsReq
         | Exclude<InitReq, Services | PlatformServices>
       >);
@@ -141,7 +142,7 @@ export interface Platform<
   // ): Effect.Effect<
   //   Resource,
   //   never,
-  //   | Provider<Resource>
+  //   | Resource["Providers"]
   //   | PropsReq
   //   | Exclude<InitReq, Services | PlatformServices>
   // >;

package/src/Provider.ts

@@ -1,8 +1,10 @@
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
 import type * as Stream from "effect/Stream";
 import type { Artifacts } from "./Artifacts.ts";
+import type { Policy } from "./Binding.ts";
 import type { ScopedPlanStatusSession } from "./Cli/index.ts";
 import type { Diff } from "./Diff.ts";
 import type { Input } from "./Input.ts";
@@ -27,16 +29,19 @@ export interface Provider<R extends ResourceLike = ResourceLike> {
     TailReq = never,
     LogsReq = never,
   >(
-    service: ProviderService<
-      R,
-      ReadReq,
-      DiffReq,
-      PrecreateReq,
-      CreateReq,
-      UpdateReq,
-      DeleteReq,
-      TailReq,
-      LogsReq
+    service: Omit<
+      ProviderService<
+        R,
+        ReadReq,
+        DiffReq,
+        PrecreateReq,
+        CreateReq,
+        UpdateReq,
+        DeleteReq,
+        TailReq,
+        LogsReq
+      >,
+      "Type"
     >,
   ) => ProviderService<
     R,
@@ -178,19 +183,6 @@ export interface ProviderService<
   }): Effect.Effect<void, any, DeleteReq>;
 }
 
-export const getProviderByType = Effect.fnUntraced(function* <
-  R extends ResourceLike,
->(resourceType: string) {
-  const context = yield* Effect.context<never>();
-  const provider: ProviderService<R> = context.mapUnsafe.get(resourceType);
-  if (!provider) {
-    return yield* Effect.die(
-      new Error(`Provider not found for ${resourceType}`),
-    );
-  }
-  return provider;
-});
-
 export const effect = <
   R extends ResourceLike,
   Req = never,
@@ -263,3 +255,133 @@ export const succeed = <
 > =>
   // @ts-expect-error
   Layer.succeed(Provider(cls.Type), service);
+
+export interface ProviderCollectionLike {
+  kind: "ProviderCollection";
+}
+
+export interface ProviderCollectionShape<Identifier extends string>
+  extends
+    Context.ServiceClass.Shape<Identifier, ProviderCollectionService>,
+    ProviderCollectionLike {}
+
+export interface ProviderCollection<Self, Identifier extends string>
+  extends
+    Context.Service<Self, ProviderCollectionService>,
+    ProviderCollectionLike {
+  readonly key: Identifier;
+  new (_: never): ProviderCollectionShape<Identifier>;
+}
+
+export const ProviderCollection =
+  <Self>() =>
+  <const ProviderId extends string>(id: ProviderId) =>
+    Context.Service<Self, ProviderCollectionService>()(
+      id,
+    ) as ProviderCollection<Self, ProviderId>;
+
+export interface ProviderCollectionService {
+  kind: "ProviderCollection";
+  get<Resource extends ResourceLike>(
+    service: string,
+  ): ProviderService<Resource> | undefined;
+}
+
+export const collection = <
+  R extends
+    | ResourceClass<any>
+    | Platform<any, any, any, any, any>
+    | Policy<any, any, any>,
+>(
+  resources: R[],
+): Effect.Effect<
+  ProviderCollectionService,
+  never,
+  R extends ResourceClass<infer R> | Platform<infer R, any, any, any, any>
+    ? Provider<R>
+    : R extends Policy<infer Self, infer _I, infer _S>
+      ? Self
+      : never
+> =>
+  Effect.gen(function* () {
+    const context = yield* Effect.context();
+
+    const providers = Object.fromEntries(
+      yield* Effect.all(
+        resources.map((resource) =>
+          "Provider" in resource
+            ? resource.Provider.asEffect().pipe(
+                Effect.map((provider) => [resource.Type, provider] as const),
+              )
+            : Effect.succeed([
+                resource.key,
+                context.mapUnsafe.get(resource.key),
+              ] as const),
+        ),
+        { concurrency: "unbounded" },
+      ),
+    );
+
+    return {
+      kind: "ProviderCollection" as const,
+      get: (service: string) => providers[service],
+    };
+  }) as any;
+
+const isProviderCollectionService = (
+  value: unknown,
+): value is ProviderCollectionService => {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    "kind" in value &&
+    value.kind === "ProviderCollection"
+  );
+};
+
+export const findProviderByType: {
+  <R extends ResourceLike>(
+    resourceType: R["Type"],
+  ): Effect.Effect<ProviderService<R>>;
+  <P extends Policy<any, any, any>>(
+    policyType: P["key"],
+  ): Effect.Effect<Effect.Success<P>>;
+} = (type: string) =>
+  tryFindProviderByType(type).pipe(
+    Effect.flatMap(
+      Option.match({
+        onNone: () => Effect.die(`Provider not found for ${type}`),
+        onSome: (provider) => Effect.succeed(provider),
+      }),
+    ),
+  );
+
+export const tryFindProviderByType: {
+  <R extends ResourceLike>(
+    resourceType: R["Type"],
+  ): Effect.Effect<Option.Option<ProviderService<R>>>;
+  <P extends Policy<any, any, any>>(
+    policyType: P["key"],
+  ): Effect.Effect<Option.Option<Effect.Success<P>>>;
+} = Effect.fnUntraced(function* <R extends ResourceLike>(
+  resourceType: R["Type"],
+) {
+  const Tag = Provider<R>(resourceType) as Context.Service<Provider<R>, any>;
+  const direct = yield* Effect.serviceOption(Tag);
+  if (Option.isSome(direct)) {
+    return direct.value;
+  }
+
+  const context = yield* Effect.context<never>();
+  for (const value of context.mapUnsafe.values()) {
+    if (isProviderCollectionService(value)) {
+      const provider = value.get(resourceType);
+      if (provider) {
+        return Option.some(provider);
+      }
+    }
+  }
+
+  console.log(context.mapUnsafe.keys());
+  return Option.none();
+}) as any;

package/src/Resource.ts

@@ -40,7 +40,10 @@ export type ResourceConstructor<R extends ResourceLike, Req = never> = {
 export type ResourceClassWithMethods<
   R extends ResourceLike,
   Methods extends { [key: string]: any },
-> = ResourceConstructor<R, Provider<R>> &
+> = ResourceConstructor<
+  R,
+  R["Providers"] extends undefined ? Provider<R> : R["Providers"]
+> &
   Effect.Effect<ResourceConstructor<R>> & {
     Self: Self<R>;
     Provider: Provider<R>;
@@ -48,7 +51,7 @@ export type ResourceClassWithMethods<
 
 export type ResourceClass<R extends ResourceLike> = ResourceConstructor<
   R,
-  Provider<R>
+  R["Providers"] extends undefined ? Provider<R> : R["Providers"]
 > &
   Effect.Effect<ResourceConstructor<R>> & {
     Self: Self<R>;
@@ -67,6 +70,7 @@ export interface ResourceLike<
   Props extends object | undefined = any,
   Attributes extends object = object,
   Binding = any,
+  Providers = any,
 > {
   /**
    * Namespace containing this Resource.
@@ -97,6 +101,8 @@ export interface ResourceLike<
   Attributes: Attributes;
   /** @internal phantom */
   Binding: Binding;
+  /** @internal phantom */
+  Providers: Providers;
 }
 
 export const isResource = (value: any): value is ResourceLike => {
@@ -108,8 +114,9 @@ export type Resource<
   Props extends object | undefined = any,
   Attributes extends object = any,
   Binding = never,
+  Providers = undefined,
 > = Pipeable &
-  ResourceLike<Type, Props, Attributes, Binding> & {
+  ResourceLike<Type, Props, Attributes, Binding, Providers> & {
     bind(sid: string, binding: Input<Binding>): Effect.Effect<void>;
     bind(
       template: TemplateStringsArray,

package/src/Stack.ts

@@ -146,9 +146,9 @@ export const make =
       Effect.map(
         ([output, stack, services]) =>
           ({
+            ...stack,
             output,
             services,
-            ...stack,
           }) satisfies CompiledStack<A, ROut | StackServices> as CompiledStack<
             A,
             ROut | StackServices

package/src/Util/service.ts

@@ -6,7 +6,7 @@ export const GenericService =
       ...args: any[]
     ) => Context.Service<any, any>,
   >() =>
-  <Kind extends string>(Kind: string): ReturnType<Fn> & Fn => {
+  <Kind extends string>(Kind: Kind): ReturnType<Fn> & Fn => {
     const service = Context.Service<any, any>(Kind);
     const make = (Type: string) => Context.Service(`${Kind}<${Type}>`);
     return Object.assign(

package/src/index.ts

@@ -1,20 +1,23 @@
 export * as AdoptPolicy from "./AdoptPolicy.ts";
 export * from "./Apply.ts";
-export * as Binding from "./Binding.ts";
-export * as Build from "./Build/index.ts";
-export * as Bundle from "./Bundle/index.ts";
+export {
+  Service as BindingService,
+  Policy,
+  type ServiceLike as BindingServiceLike,
+  type ServiceShape as BindingServiceShape,
+  type PolicyLike,
+  type PolicyShape,
+} from "./Binding.ts";
 export * from "./Config.ts";
 export * from "./Destroy.ts";
 export * from "./Diff.ts";
-export * as Http from "./Http.ts";
 export * from "./Input.ts";
 export * from "./InstanceId.ts";
-export * as Kubernetes from "./Kubernetes/index.ts";
 export * from "./Namespace.ts";
-export * as Output from "./Output.ts";
+export type { Output } from "./Output.ts";
 export * from "./PhysicalName.ts";
 export * as Plan from "./Plan.ts";
-export { Provider } from "./Provider.ts";
+export { Provider, ProviderCollection } from "./Provider.ts";
 export * from "./Random.ts";
 export * from "./Ref.ts";
 export * as RemovalPolicy from "./RemovalPolicy.ts";