alchemy 2.0.0-beta.1 → 2.0.0-beta.12

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";
@@ -33,7 +33,7 @@ export type Main<Services = never> = void | {
 };
 
 export type Rpc<Shape> = {
-  "~alchemy-effect/rpc": Shape;
+  "~alchemy/rpc": Shape;
 };
 
 // services provided to the Resource
@@ -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>
   // >;
@@ -158,7 +159,7 @@ export interface Platform<
   ): Effect.Effect<
     Resource & Rpc<Shape>,
     never,
-    | Provider<Resource>
+    | Resource["Providers"]
     | PropsReq
     | Exclude<InitReq, Services | PlatformServices>
   >;
@@ -219,10 +220,15 @@ export const Platform = <
             //     return new Response("Hello, world!");
             //   }
             // }
-            resource(id, {
-              ...props,
-              isExternal: true,
-            })
+            resource(
+              id,
+              Effect.isEffect(props)
+                ? Effect.map(props, (p: any) => ({ ...p, isExternal: true }))
+                : {
+                    ...props,
+                    isExternal: true,
+                  },
+            )
           : Effect.flatMap(
               // this is a tagged resource
               Effect.serviceOption(cls.Self),

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;
+  }
+
+  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

@@ -31,16 +31,19 @@ export type ResourceConstructor<R extends ResourceLike, Req = never> = {
           },
         ]
   ): Effect.Effect<R, never, Req>;
-  // <PropsReq = never>(
-  //   id: string,
-  //   props: Effect.Effect<Input<R["Props"]>, never, PropsReq>,
-  // ): Effect.Effect<R, never, PropsReq | Req>;
+  <PropsReq = never>(
+    id: string,
+    props: Effect.Effect<Input<R["Props"]>, never, PropsReq>,
+  ): Effect.Effect<R, never, PropsReq | Req>;
 };
 
 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

@@ -7,6 +7,7 @@ import { Path } from "effect/Path";
 import type { Scope } from "effect/Scope";
 import type { HttpClient } from "effect/unstable/http/HttpClient";
 import type { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
+import type { AuthProviders } from "./Auth/AuthProvider.ts";
 import { DotAlchemy } from "./Config.ts";
 import type { Input, InputProps } from "./Input.ts";
 import * as Output from "./Output.ts";
@@ -23,7 +24,8 @@ export type StackServices =
   | Path
   | DotAlchemy
   | HttpClient
-  | ChildProcessSpawner;
+  | ChildProcessSpawner
+  | AuthProviders;
 
 export type Stack = Context.ServiceClass.Shape<
   "Stack",
@@ -138,36 +140,45 @@ export const make =
   <A, Err = never, Req extends ROut | StackServices = never>(
     effect: Effect.Effect<A, Err, Req>,
   ) =>
-    Effect.all([
-      effect,
-      Stack.asEffect(),
-      Effect.context<ROut | StackServices>(),
-    ]).pipe(
-      Effect.map(
-        ([output, stack, services]) =>
-          ({
-            output,
-            services,
-            ...stack,
-          }) satisfies CompiledStack<A, ROut | StackServices> as CompiledStack<
-            A,
-            ROut | StackServices
-          >,
-      ),
-      Effect.provide(providers),
-      Effect.provideServiceEffect(
-        Stack,
-        Stage.asEffect().pipe(
+    Effect.scope.pipe(
+      Effect.flatMap((scope) => {
+        const stackLayer = Layer.effect(
+          Stack,
+          Stage.asEffect().pipe(
+            Effect.map(
+              (stage) =>
+                stack ?? {
+                  name,
+                  stage,
+                  resources: {},
+                  bindings: {},
+                },
+            ),
+            Effect.tap(Effect.logInfo),
+          ),
+        );
+        return providers.pipe(
+          Layer.provideMerge(stackLayer),
+          Layer.buildWithScope(scope),
+        );
+      }),
+      Effect.flatMap((context) =>
+        Effect.all([
+          effect,
+          Stack.asEffect(),
+          Effect.context<ROut | StackServices>(),
+        ]).pipe(
           Effect.map(
-            (stage) =>
-              (stack ?? {
-                name,
-                stage,
-                resources: {},
-                bindings: {},
-              }) satisfies Stack["Service"],
+            ([output, stack, services]): CompiledStack<
+              A,
+              ROut | StackServices
+            > => ({
+              ...stack,
+              output,
+              services,
+            }),
           ),
-          Effect.tap(Effect.logInfo),
+          Effect.provideContext(context),
         ),
       ),
     );

package/src/State/LocalState.ts

@@ -3,10 +3,51 @@ import * as FileSystem from "effect/FileSystem";
 import * as Layer from "effect/Layer";
 import * as Path from "effect/Path";
 import type { PlatformError } from "effect/PlatformError";
+import * as Redacted from "effect/Redacted";
 import { decodeFqn, encodeFqn } from "../FQN.ts";
 import { isResource } from "../Resource.ts";
 import { State, StateStoreError, type StateService } from "./State.ts";
 
+const REDACTED_MARKER = "__redacted__";
+
+const encodeState = (value: unknown): unknown => {
+  if (value === null || value === undefined) return value;
+  if (Redacted.isRedacted(value)) {
+    return {
+      [REDACTED_MARKER]: encodeState(Redacted.value(value)),
+    };
+  }
+  if (isResource(value)) {
+    return {
+      id: value.LogicalId,
+      type: value.Type,
+      props: encodeState(value.Props),
+      attr: encodeState(value.Attributes),
+    };
+  }
+  if (Array.isArray(value)) return value.map(encodeState);
+  if (typeof value === "object") {
+    const result: Record<string, unknown> = {};
+    for (const [k, v] of Object.entries(value)) {
+      result[k] = encodeState(v);
+    }
+    return result;
+  }
+  return value;
+};
+
+const reviveState = (_key: string, value: unknown): unknown => {
+  if (
+    value !== null &&
+    typeof value === "object" &&
+    !Array.isArray(value) &&
+    REDACTED_MARKER in value
+  ) {
+    return Redacted.make((value as Record<string, unknown>)[REDACTED_MARKER]);
+  }
+  return value;
+};
+
 export const LocalState = Layer.effect(
   State,
   Effect.gen(function* () {
@@ -65,7 +106,7 @@ export const LocalState = Layer.effect(
         ),
       get: (request) =>
         fs.readFile(resource(request)).pipe(
-          Effect.map((file) => JSON.parse(file.toString())),
+          Effect.map((file) => JSON.parse(file.toString(), reviveState)),
           recover,
         ),
       getReplacedResources: Effect.fnUntraced(function* (request) {
@@ -84,21 +125,7 @@ export const LocalState = Layer.effect(
           Effect.flatMap(() =>
             fs.writeFileString(
               resource(request),
-              JSON.stringify(
-                request.value,
-                (k, v) => {
-                  if (isResource(v)) {
-                    return {
-                      id: v.LogicalId,
-                      type: v.Type,
-                      props: v.Props,
-                      attr: v.Attributes,
-                    };
-                  }
-                  return v;
-                },
-                2,
-              ),
+              JSON.stringify(encodeState(request.value), null, 2),
             ),
           ),
           recover,

package/src/Test/Bun.ts

@@ -11,6 +11,7 @@ import type { HttpClient } from "effect/unstable/http/HttpClient";
 import type { HookOptions } from "node:test";
 import * as Apply from "../Apply.ts";
 import { provideFreshArtifactStore } from "../Artifacts.ts";
+import { AuthProviders } from "../Auth/AuthProvider.ts";
 import { DotAlchemy, dotAlchemy } from "../Config.ts";
 import type { Input } from "../Input.ts";
 import * as Plan from "../Plan.ts";
@@ -49,6 +50,7 @@ const run = <A>(effect: TestEffect<A>) =>
       Effect.provide(Layer.succeed(ConfigProvider, configProvider)),
     );
   }).pipe(
+    Effect.provideService(AuthProviders, {}),
     Effect.provide(Layer.provideMerge(alchemy, platform)),
     Effect.scoped,
     Effect.runPromise,
@@ -211,6 +213,7 @@ const exec = <A, B>(
       Effect.provide(Layer.succeed(ConfigProvider, configProvider)),
     );
   }).pipe(
+    Effect.provideService(AuthProviders, {}),
     Effect.provide(Layer.succeed(Stage, options?.stage ?? "test")),
     Effect.provide(TestCli),
     Effect.provide(Layer.provideMerge(alchemy, platform)),