alchemy 2.0.0-beta.65 → 2.0.0-beta.67

package/src/Docker/Image.ts

@@ -5,7 +5,7 @@ import * as Artifacts from "../Artifacts.ts";
 import { isResolved } from "../Diff.ts";
 import * as Provider from "../Provider.ts";
 import { Resource } from "../Resource.ts";
-import { Docker, dockerPhysicalName } from "./Docker.ts";
+import { Docker, dockerContextName, dockerPhysicalName } from "./Docker.ts";
 import type { Providers } from "./Providers.ts";
 import {
   type ImageRegistry,
@@ -55,6 +55,8 @@ export interface ImageProps {
   registry?: ImageRegistry;
   /** Skip registry push even when `registry` is set. @default false */
   skipPush?: boolean;
+  /** Docker context name or context resource. */
+  context?: Docker.ContextRef;
   /** Docker build configuration. */
   build: DockerBuildOptions;
 }
@@ -121,6 +123,16 @@ export interface Image extends Resource<
  *   },
  * });
  * ```
+ *
+ * @section Docker Context
+ * @example Build in a named Docker context
+ * ```typescript
+ * const image = yield* Docker.Image("app", {
+ *   name: "my-app",
+ *   context: "remote-build",
+ *   build: { context: "./app" },
+ * });
+ * ```
  */
 export const Image = Resource<Image>("Docker.Image");
 
@@ -138,6 +150,7 @@ export const ImageProvider = () =>
         instanceId: string,
       ) {
         const name = yield* dockerPhysicalName(id, props, instanceId);
+        const engineContext = dockerContextName(props.context);
         const tag = props.tag ?? "latest";
         const ref = `${name}:${tag}`;
 
@@ -152,6 +165,7 @@ export const ImageProvider = () =>
           "cache-from": props.build.cacheFrom,
           "cache-to": props.build.cacheTo,
           args: props.build.options,
+          engineContext,
         });
 
         // Read the freshly built image's id and creation time straight from
@@ -159,7 +173,7 @@ export const ImageProvider = () =>
         return {
           name,
           tag,
-          image: yield* docker.image.inspect(ref),
+          image: yield* docker.image.inspect(ref, engineContext),
           ref,
         };
       }, Artifacts.cached("build"));
@@ -188,13 +202,14 @@ export const ImageProvider = () =>
       return Image.Provider.of({
         list: () => Effect.succeed([]),
         read: Effect.fn(function* ({ id, instanceId, olds, output }) {
+          const context = dockerContextName(olds.context);
           const ref =
             output?.imageRef ??
             (yield* dockerPhysicalName(id, olds, instanceId).pipe(
               Effect.map((name) => `${name}:${olds.tag ?? "latest"}`),
             ));
           const image = yield* docker.image
-            .inspect(ref)
+            .inspect(ref, context)
             .pipe(
               Effect.catchReason(
                 "PlatformError",
@@ -212,14 +227,20 @@ export const ImageProvider = () =>
             builtAt: output?.builtAt ?? parseCreatedAt(image.Created),
           };
         }),
-        diff: Effect.fn(function* ({ id, instanceId, news, output }) {
+        diff: Effect.fn(function* ({ id, instanceId, news, output, olds }) {
           if (!isResolved(news) || !output) return undefined;
+          if (
+            dockerContextName(olds.context) !== dockerContextName(news.context)
+          ) {
+            return { action: "update" };
+          }
           const { image } = yield* buildAndInspectImage(id, news, instanceId);
           if (output?.imageId !== image.Id) {
             return { action: "update" };
           }
         }),
         reconcile: Effect.fn(function* ({ id, instanceId, news, session }) {
+          const context = dockerContextName(news.context);
           const { name, tag, image, ref } = yield* buildAndInspectImage(
             id,
             news,
@@ -234,7 +255,7 @@ export const ImageProvider = () =>
             );
             targetImageRef = withRegistryHost(ref, news.registry);
             repoDigest = yield* docker.image
-              .push(ref, news.registry)
+              .push(ref, news.registry, undefined, context)
               .pipe(
                 Effect.map((result) => parseRepoDigest(ref, result.stdout)),
               );
@@ -249,9 +270,9 @@ export const ImageProvider = () =>
             builtAt: parseCreatedAt(image.Created),
           };
         }),
-        delete: Effect.fn(({ output }) =>
+        delete: Effect.fn(({ olds, output }) =>
           docker.image
-            .remove(output.imageRef)
+            .remove(output.imageRef, undefined, dockerContextName(olds.context))
             .pipe(
               Effect.catchReason(
                 "PlatformError",

package/src/Docker/Network.ts

@@ -9,7 +9,11 @@ import {
   hasAlchemyTags,
   stripInternalTags,
 } from "../Tags.ts";
-import { Docker, dockerPhysicalName } from "./Docker.ts";
+import {
+  Docker,
+  dockerEngineContextName,
+  dockerPhysicalName,
+} from "./Docker.ts";
 import type { Providers } from "./Providers.ts";
 
 export interface NetworkProps {
@@ -25,6 +29,13 @@ export interface NetworkProps {
   enableIPv6?: boolean;
   /** Network labels. */
   labels?: Record<string, string>;
+  /**
+   * The engine the network is created on: a Docker context name, a
+   * `Docker.Context` resource, or a `Docker.Swarm` — overlay networks
+   * require a swarm manager, and passing the swarm orders the network after
+   * the swarm is initialized.
+   */
+  context?: Docker.EngineRef;
 }
 
 export interface Network extends Resource<
@@ -83,9 +94,10 @@ export const NetworkProvider = () =>
       return Network.Provider.of({
         list: () => Effect.succeed([]),
         read: Effect.fn(function* ({ id, instanceId, olds, output }) {
+          const context = dockerEngineContextName(olds?.context);
           const name = yield* dockerPhysicalName(id, olds, instanceId);
           const info = yield* docker.network
-            .inspect(name)
+            .inspect(name, context)
             .pipe(
               Effect.catchReason(
                 "PlatformError",
@@ -101,8 +113,14 @@ export const NetworkProvider = () =>
           const owned = yield* hasAlchemyTags(id, info.Labels ?? undefined);
           return owned ? attrs : Unowned(attrs);
         }),
-        diff: Effect.fn(function* ({ id, output, instanceId, news }) {
+        diff: Effect.fn(function* ({ id, output, instanceId, news, olds }) {
           if (!isResolved(news) || !output) return undefined;
+          if (
+            dockerEngineContextName(olds?.context) !==
+            dockerEngineContextName(news?.context)
+          ) {
+            return { action: "replace", deleteFirst: true };
+          }
           const args = yield* makeNetworkArgs(id, news, instanceId);
           // Auto-generated names are engine-owned: the deployed name stays
           // authoritative even if the generator would name this id differently
@@ -120,15 +138,18 @@ export const NetworkProvider = () =>
           }
         }),
         reconcile: Effect.fn(function* ({ output, id, instanceId, news }) {
+          const context = dockerEngineContextName(news?.context);
           if (output) {
-            const refreshed = yield* docker.network.inspect(output.id).pipe(
-              Effect.map(toNetworkAttributes),
-              Effect.catchReason(
-                "PlatformError",
-                "NotFound",
-                () => Effect.undefined,
-              ),
-            );
+            const refreshed = yield* docker.network
+              .inspect(output.id, context)
+              .pipe(
+                Effect.map(toNetworkAttributes),
+                Effect.catchReason(
+                  "PlatformError",
+                  "NotFound",
+                  () => Effect.undefined,
+                ),
+              );
             if (refreshed) return refreshed;
           }
           const args = yield* makeNetworkArgs(id, news, instanceId);
@@ -136,12 +157,15 @@ export const NetworkProvider = () =>
           const { stdout: createdId } = yield* docker.network.create({
             ...args,
             label: { ...internalTags, ...args.label },
+            context,
           });
-          return toNetworkAttributes(yield* docker.network.inspect(createdId));
+          return toNetworkAttributes(
+            yield* docker.network.inspect(createdId, context),
+          );
         }),
-        delete: Effect.fn(({ output }) =>
+        delete: Effect.fn(({ olds, output }) =>
           docker.network
-            .remove(output.id)
+            .remove(output.id, dockerEngineContextName(olds?.context))
             .pipe(
               Effect.catchReason(
                 "PlatformError",

package/src/Docker/Providers.ts

@@ -1,10 +1,13 @@
 import * as Layer from "effect/Layer";
 import * as Provider from "../Provider.ts";
 import { Container, ContainerProvider } from "./Container.ts";
+import { Context, ContextProvider } from "./Context.ts";
 import { DockerLive } from "./Docker.ts";
 import { Image, ImageProvider } from "./Image.ts";
 import { Network, NetworkProvider } from "./Network.ts";
 import { RemoteImage, RemoteImageProvider } from "./RemoteImage.ts";
+import { Service, ServiceProvider } from "./Service.ts";
+import { Swarm, SwarmProvider } from "./Swarm.ts";
 import { Volume, VolumeProvider } from "./Volume.ts";
 
 export class Providers extends Provider.ProviderCollection<Providers>()(
@@ -22,7 +25,16 @@ export type ProviderRequirements = Layer.Services<ReturnType<typeof providers>>;
 export const providers = () =>
   Layer.effect(
     Providers,
-    Provider.collection([Container, Image, Network, RemoteImage, Volume]),
+    Provider.collection([
+      Container,
+      Image,
+      Network,
+      RemoteImage,
+      Volume,
+      Context,
+      Service,
+      Swarm,
+    ]),
   ).pipe(
     Layer.provide(
       Layer.mergeAll(
@@ -31,6 +43,9 @@ export const providers = () =>
         NetworkProvider(),
         RemoteImageProvider(),
         VolumeProvider(),
+        ContextProvider(),
+        ServiceProvider(),
+        SwarmProvider(),
       ),
     ),
     Layer.provideMerge(DockerLive),

package/src/Docker/RemoteImage.ts

@@ -2,7 +2,7 @@ import * as Effect from "effect/Effect";
 import { isResolved } from "../Diff.ts";
 import * as Provider from "../Provider.ts";
 import { Resource } from "../Resource.ts";
-import { Docker } from "./Docker.ts";
+import { Docker, dockerContextName } from "./Docker.ts";
 import type { Providers } from "./Providers.ts";
 import {
   type ImageRegistry,
@@ -44,6 +44,8 @@ export interface RemoteImageProps {
    * @default false
    */
   skipPush?: boolean;
+  /** Docker context name or context resource. */
+  context?: Docker.ContextRef;
 }
 
 export interface RemoteImage extends Resource<
@@ -112,6 +114,16 @@ export interface RemoteImage extends Resource<
  *   },
  * });
  * ```
+ *
+ * @section Docker Context
+ * @example Pull through a named Docker context
+ * ```typescript
+ * const nginx = yield* Docker.RemoteImage("nginx", {
+ *   name: "nginx",
+ *   tag: "alpine",
+ *   context: "remote-build",
+ * });
+ * ```
  */
 export const RemoteImage = Resource<RemoteImage>("Docker.RemoteImage");
 
@@ -124,8 +136,9 @@ export const RemoteImageProvider = () =>
       return RemoteImage.Provider.of({
         list: () => Effect.succeed([]),
         read: Effect.fn(function* ({ olds, output }) {
+          const context = dockerContextName(olds.context);
           const ref = output?.imageRef ?? targetImageRef(olds);
-          return yield* docker.image.inspect(ref).pipe(
+          return yield* docker.image.inspect(ref, context).pipe(
             Effect.map((image) => ({
               imageRef: ref,
               imageId: image.Id,
@@ -141,9 +154,11 @@ export const RemoteImageProvider = () =>
             ),
           );
         }),
-        diff: Effect.fn(function* ({ output, news }) {
+        diff: Effect.fn(function* ({ output, news, olds }) {
           if (!isResolved(news)) return undefined;
           if (
+            dockerContextName(olds.context) !==
+              dockerContextName(news.context) ||
             !output ||
             news.alwaysPull !== false ||
             output.imageRef !== targetImageRef(news)
@@ -152,16 +167,17 @@ export const RemoteImageProvider = () =>
           }
         }),
         reconcile: Effect.fn(function* ({ news, session }) {
+          const context = dockerContextName(news.context);
           const sourceRef = remoteImageRef(news);
           yield* session.note(`Pulling Docker image: ${sourceRef}`);
-          yield* docker.image.pull(sourceRef, news.platform);
+          yield* docker.image.pull(sourceRef, news.platform, context);
 
           const finalRef = targetImageRef(news);
           if (finalRef !== sourceRef) {
             yield* session.note(
               `Tagging Docker image: ${sourceRef} -> ${finalRef}`,
             );
-            yield* docker.image.tag(sourceRef, finalRef);
+            yield* docker.image.tag(sourceRef, finalRef, context);
           }
 
           let repoDigest: string | undefined;
@@ -170,7 +186,7 @@ export const RemoteImageProvider = () =>
               `Pushing image to registry "${news.registry.server}"`,
             );
             repoDigest = yield* docker.image
-              .push(finalRef, news.registry)
+              .push(finalRef, news.registry, undefined, context)
               .pipe(
                 Effect.map((result) =>
                   parseRepoDigest(finalRef, result.stdout),
@@ -178,7 +194,7 @@ export const RemoteImageProvider = () =>
               );
           }
 
-          const inspected = yield* docker.image.inspect(finalRef);
+          const inspected = yield* docker.image.inspect(finalRef, context);
           return {
             imageRef: finalRef,
             imageId: inspected.Id,