alchemy 2.0.0-beta.74 → 2.0.0-beta.76

package/src/AWS/Local/ImageSourceTrigger.ts

@@ -0,0 +1,102 @@
+/** @effect-diagnostics anyUnknownInErrorContext:off */
+
+/**
+ * INTERNAL — the "image source changed" trigger stream shared by the floci
+ * dev providers that rebuild a Docker image on file change
+ * ([ECS FlociTaskProvider](../ECS/FlociTaskProvider.ts),
+ * [ECS FlociServiceProvider](../ECS/FlociServiceProvider.ts),
+ * [Lambda FlociMicrovmImageProvider](../Lambda/FlociMicrovmImageProvider.ts)).
+ * NOT exported from any service `index.ts`.
+ */
+
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import * as Stream from "effect/Stream";
+import * as Bundle from "../../Bundle/Bundle.ts";
+import { isInlineDockerfile } from "../../Docker/Dockerfile.ts";
+import {
+  imageSourceKind,
+  makeBunBootstrap,
+  makeImageSource,
+  type BundledImageSource,
+  type ImageSourceLike,
+} from "../ECR/ImageSource.ts";
+
+/**
+ * A stream of "the image source changed" triggers for a props bag:
+ *
+ * - `main` — a `Bundle.watch` over the exact module graph the deploy
+ *   bundles (rebuild successes are the trigger; rebuild errors are logged
+ *   and swallowed);
+ * - `context` — a debounced recursive `fs.watch` of the build context (and
+ *   the Dockerfile's directory when it lives outside the context);
+ * - `image` (registry ref) / inline-dockerfile-only — nothing local to
+ *   watch: an empty stream.
+ */
+export const imageSourceTrigger = Effect.fn(function* (options: {
+  /** Logical id, for log prefixes. */
+  id: string;
+  source: ImageSourceLike;
+  isExternal: boolean | undefined;
+}) {
+  const { id, source } = options;
+  const kind = imageSourceKind(source);
+
+  if (kind === "main") {
+    const imageSource = yield* makeImageSource;
+    const plan = yield* imageSource.watchMain({
+      source: source as BundledImageSource,
+      isExternal: options.isExternal,
+      bootstrap: makeBunBootstrap(source.handler ?? "default"),
+    });
+    return Bundle.watch(plan.inputOptions, plan.outputOptions, plan.extra).pipe(
+      Stream.tap((event) =>
+        event._tag === "Error"
+          ? Effect.logWarning(
+              `[alchemy dev] ${id}: rebuild failed: ${event.error.message}`,
+            )
+          : Effect.void,
+      ),
+      Stream.filter((event) => event._tag === "Success"),
+      Stream.debounce("200 millis"),
+      Stream.map(() => undefined),
+    ) as Stream.Stream<void>;
+  }
+
+  if (kind === "context") {
+    if (source.context === undefined) {
+      // Inline-dockerfile-only builds have no local files to watch — the
+      // content is a prop, and prop changes flow through the dev diff.
+      return Stream.empty as Stream.Stream<void>;
+    }
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const context = path.resolve(source.context);
+    const streams: Stream.Stream<unknown, any>[] = [
+      fs.watch(context, { recursive: true }),
+    ];
+    // A path Dockerfile living OUTSIDE the context dir is watched too.
+    if (
+      source.dockerfile !== undefined &&
+      !isInlineDockerfile(source.dockerfile)
+    ) {
+      const dockerfile = path.resolve(source.dockerfile);
+      if (!dockerfile.startsWith(`${context}/`)) {
+        streams.push(fs.watch(path.dirname(dockerfile)));
+      }
+    }
+    return Stream.mergeAll(streams, { concurrency: streams.length }).pipe(
+      Stream.debounce("300 millis"),
+      Stream.map(() => undefined),
+      Stream.catchCause((cause) =>
+        Stream.fromEffect(
+          Effect.logWarning(`[alchemy dev] ${id}: context watch failed`, cause),
+        ).pipe(Stream.drain),
+      ),
+    ) as Stream.Stream<void>;
+  }
+
+  // Registry `image` refs have nothing local to watch.
+  return Stream.empty as Stream.Stream<void>;
+});

package/src/AWS/Local/Local.ts

@@ -12,9 +12,11 @@ import * as RpcServer from "../../Local/RpcServer.ts";
 import { FlociServiceProvider } from "../ECS/FlociServiceProvider.ts";
 import { FlociTaskProvider } from "../ECS/FlociTaskProvider.ts";
 import { FlociFunctionProvider } from "../Lambda/FlociFunctionProvider.ts";
+import { FlociMicrovmImageProvider } from "../Lambda/FlociMicrovmImageProvider.ts";
 
 Layer.mergeAll(
   FlociFunctionProvider(),
+  FlociMicrovmImageProvider(),
   FlociTaskProvider(),
   FlociServiceProvider(),
 ).pipe(

package/src/AWS/Local/ProviderContext.ts

@@ -1,12 +1,17 @@
 /** @effect-diagnostics anyUnknownInErrorContext:off */
 
+import { Credentials } from "@distilled.cloud/aws/Credentials";
+import { Endpoint } from "@distilled.cloud/aws";
+import { Region } from "@distilled.cloud/aws/Region";
 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 * as Predicate from "effect/Predicate";
 import * as Stream from "effect/Stream";
 import type { ProviderService } from "../../Provider.ts";
 import type { ResourceLike } from "../../Resource.ts";
+import { AWSEnvironment } from "../Environment.ts";
 
 /**
  * Wraps a {@link ProviderService} so that EVERY lifecycle method
@@ -28,6 +33,23 @@ export const withProviderContext = <R extends ResourceLike>(
   new Proxy(provider, {
     get: (target, prop) => {
       const value = (target as any)[prop];
+      if (prop === "modes" && value !== undefined) {
+        // Mode-resolved variants (`findProviderByType(type, mode)`, used for
+        // stamped-mode deletes and `Alchemy.remote()`) bypass this Proxy —
+        // wrap the services THEY resolve to as well, so a live variant's
+        // ops carry the same context. A local variant's own data-plane
+        // override is provided closer and still wins.
+        return Object.fromEntries(
+          Object.entries(value as Record<string, Effect.Effect<any>>).map(
+            ([mode, build]) => [
+              mode,
+              Effect.map(build, (resolved) =>
+                withProviderContext(resolved as ProviderService<R>, services),
+              ),
+            ],
+          ),
+        );
+      }
       if (!Predicate.isFunction(value)) return value;
       return (...args: any[]) => {
         const result: unknown = value(...args);
@@ -42,6 +64,77 @@ export const withProviderContext = <R extends ResourceLike>(
     },
   });
 
+/**
+ * Capture the ambient AWS environment — the exact tag set a local data
+ * plane overrides: {@link Endpoint}, {@link Region}, {@link Credentials},
+ * {@link AWSEnvironment} — as a layer that reproduces it verbatim. An
+ * absent Endpoint is pinned as `undefined` (the SDK default resolver), so
+ * a later ambient override cannot leak in.
+ */
+export const captureAwsEnvironment: Effect.Effect<
+  Layer.Layer<any, never, never>
+> = Effect.gen(function* () {
+  let ctx = Context.empty();
+  const endpoint = yield* Effect.serviceOption(Endpoint.Endpoint);
+  ctx = Context.add(
+    ctx,
+    Endpoint.Endpoint,
+    Option.getOrElse(endpoint, () => Effect.succeed(undefined)),
+  );
+  const region = yield* Effect.serviceOption(Region);
+  if (Option.isSome(region)) ctx = Context.add(ctx, Region, region.value);
+  const credentials = yield* Effect.serviceOption(Credentials);
+  if (Option.isSome(credentials)) {
+    ctx = Context.add(ctx, Credentials, credentials.value);
+  }
+  const environment = yield* Effect.serviceOption(AWSEnvironment);
+  if (Option.isSome(environment)) {
+    ctx = Context.add(ctx, AWSEnvironment, environment.value);
+  }
+  return Layer.succeedContext(ctx) as Layer.Layer<any, never, never>;
+});
+
+/**
+ * Pin every provider in a collection (and every mode variant it lazily
+ * resolves) to the AWS environment captured at REGISTRATION, provided
+ * closest around each lifecycle effect. Providers therefore always run
+ * against the environment they were registered with, regardless of the
+ * caller's ambient context — which in an `alchemy dev` run is the emulator
+ * (see AWS/Providers.ts): composition-time lookups get the emulator for
+ * free while live-mode and mode-agnostic providers keep hitting the real
+ * cloud. Local variants still win — their own data-plane override is
+ * provided closer.
+ */
+export const pinCollectionEnvironment = <
+  A extends {
+    readonly kind: "ProviderCollection";
+    get(service: string): ProviderService<any> | undefined;
+    readonly providers: Record<string, ProviderService>;
+  },
+>(
+  collection: A,
+  environment: Layer.Layer<any, never, never>,
+): A => {
+  const wrap = (provider: ProviderService | undefined) => {
+    if (provider === undefined) return undefined;
+    // Stamp the registration-captured live environment so Binding clients
+    // for `Alchemy.remote()` resources can provide it closest — in a
+    // `dev` run ambient is the emulator, and an unwrapped live client
+    // would miss the real cloud.
+    Object.assign(provider, { liveDataPlane: () => environment });
+    return withProviderContext(provider, environment);
+  };
+  const wrapped: Record<string, ProviderService> = {};
+  for (const [type, provider] of Object.entries(collection.providers)) {
+    wrapped[type] = wrap(provider)!;
+  }
+  return {
+    ...collection,
+    get: (service: string) => wrapped[service] ?? wrap(collection.get(service)),
+    providers: wrapped,
+  } as A;
+};
+
 const isProviderService = (value: unknown): value is ProviderService<any> =>
   Predicate.hasProperty(value, "reconcile") &&
   Predicate.isFunction(value.reconcile);