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

package/src/Test/Vitest.ts

@@ -1,6 +1,6 @@
 import type * as aws from "@distilled.cloud/aws";
 import * as cf from "@distilled.cloud/cloudflare";
-import { NodeServices } from "@effect/platform-node";
+// import { NodeServices } from "@effect/platform-node";
 import { expect, it } from "@effect/vitest";
 import { Logger } from "effect";
 import * as Config from "effect/Config";
@@ -24,8 +24,10 @@ import * as Cloudflare from "../Cloudflare/index.ts";
 import type { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
 import { apply } from "../Apply.ts";
 import { Artifacts, provideFreshArtifactStore } from "../Artifacts.ts";
-import * as Credentials from "../AWS/Credentials.ts";
-import * as Region from "../AWS/Region.ts";
+import { AuthProviders } from "../Auth/AuthProvider.ts";
+import * as AWSCredentials from "../AWS/Credentials.ts";
+import * as AWSEnvironment from "../AWS/Environment.ts";
+import * as AWSRegion from "../AWS/Region.ts";
 import type { Command } from "../Build/Command.ts";
 import type { Cli } from "../Cli/index.ts";
 import {
@@ -44,6 +46,7 @@ import * as Serverless from "../Serverless/index.ts";
 import * as Stack from "../Stack.ts";
 import * as Stage from "../Stage.ts";
 import * as State from "../State/index.ts";
+import { PlatformServices } from "../Util/PlatformServices.ts";
 import { TestCli } from "./TestCli.ts";
 
 export const expectEmptyObject = () =>
@@ -78,56 +81,61 @@ type Provided =
   | Server.ProcessContext
   | Server.ServerHost
   | Serverless.FunctionContext
-  | AWS.StageConfig
+  | AWSEnvironment.AWSEnvironment
   | Artifacts
   | Provider<Command>
   | AWS.Providers
   | Cloudflare.Providers
-  | ChildProcessSpawner;
+  | ChildProcessSpawner
+  | AuthProviders;
 
 const quietLogger = Logger.make(() => {
   // console.log(options.message);
 });
 
 const platform = Layer.mergeAll(
-  NodeServices.layer,
+  PlatformServices,
   FetchHttpClient.layer,
   Logger.layer([process.env.VERBOSE ? Logger.consolePretty() : quietLogger]),
 );
 
-const awsStageConfig = Layer.effect(
-  AWS.StageConfig,
+const awsEnvironment = Layer.unwrap(
   Effect.gen(function* () {
-    const AWS_PROFILE = yield* Config.string("AWS_PROFILE").pipe(
+    const profileName = yield* Config.string("AWS_PROFILE").pipe(
       Config.withDefault("default"),
     );
-
     const LOCAL = yield* Config.boolean("LOCAL").pipe(
       Config.withDefault(false),
     );
-
     const LOCALSTACK_ENDPOINT = yield* Config.string(
       "LOCALSTACK_ENDPOINT",
     ).pipe(Config.withDefault("http://localhost.localstack.cloud:4566"));
 
-    return AWS.StageConfig.of({
-      profile: LOCAL ? undefined : AWS_PROFILE,
-      region: LOCAL ? "us-east-1" : undefined,
-      credentials: LOCAL
-        ? {
-            accessKeyId: "test",
-            secretAccessKey: "test",
-            sessionToken: "test",
-          }
-        : undefined,
-      endpoint: LOCAL ? LOCALSTACK_ENDPOINT : undefined,
-    });
+    if (LOCAL) {
+      return AWSEnvironment.makeEnvironment({
+        accountId: "000000000000",
+        region: "us-east-1",
+        credentials: {
+          accessKeyId: "test",
+          secretAccessKey: "test",
+          sessionToken: "test",
+        },
+        endpoint: LOCALSTACK_ENDPOINT,
+      });
+    }
+    return Layer.effect(
+      AWSEnvironment.AWSEnvironment,
+      AWSEnvironment.loadDefault(),
+    ).pipe(Layer.orDie);
   }),
 );
 
 const awsProviders = Layer.provideMerge(
   AWS.providers(),
-  Layer.mergeAll(Credentials.fromStageConfig(), Region.fromStageConfig()),
+  Layer.provideMerge(
+    Layer.mergeAll(AWSRegion.fromEnvironment, AWSCredentials.fromEnvironment),
+    awsEnvironment,
+  ),
 );
 
 const cfProviders = Layer.provideMerge(
@@ -169,7 +177,7 @@ const runWithContext = <A, Err>(
 
   const alchemy = Layer.provideMerge(
     Layer.mergeAll(options.state ?? State.LocalState, TestCli),
-    Layer.mergeAll(awsStageConfig, stack, dotAlchemy),
+    Layer.mergeAll(stack, dotAlchemy),
   );
 
   const context = {
@@ -204,6 +212,7 @@ const runWithContext = <A, Err>(
       ),
     ),
     Effect.provideService(Stage.Stage, "test"),
+    Effect.provideService(AuthProviders, {}),
     Effect.provideService(ExecutionContext, context as any),
     Effect.provideService(Server.ServerHost, {
       run: (_effect) => Effect.void,
@@ -212,7 +221,7 @@ const runWithContext = <A, Err>(
       MinimumLogLevel,
       process.env.DEBUG ? "Debug" : "Info",
     ),
-    Effect.provide(NodeServices.layer),
+    Effect.provide(PlatformServices),
   );
 };
 

package/src/Util/Clank.ts

@@ -0,0 +1,77 @@
+import * as p from "@clack/prompts";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import { ChildProcess } from "effect/unstable/process";
+
+export class PromptCancelled extends Data.TaggedError("PromptCancelled") {}
+export const retryIfCancelled = Effect.retry({
+  while: (e: unknown) => e instanceof PromptCancelled,
+});
+
+/**
+ * Wraps a clack prompt (which returns a `Promise<T | symbol>` where the
+ * symbol indicates user cancellation) in an Effect.
+ *
+ * Returns `undefined` if the user cancels (Ctrl+C / Escape).
+ *
+ * Uses `Effect.callback` so fiber interruption propagates via the abort
+ * signal to any async resources we own; the clack prompt itself is left
+ * to resolve — its result is ignored after interruption.
+ */
+export const prompt = <T>(
+  fn: () => Promise<T | symbol>,
+): Effect.Effect<T, PromptCancelled> =>
+  Effect.callback<T, PromptCancelled>((resume, signal) => {
+    let settled = false;
+    fn().then(
+      (result) => {
+        if (settled || signal.aborted) return;
+        settled = true;
+        if (p.isCancel(result)) {
+          resume(Effect.fail(new PromptCancelled()));
+        } else {
+          resume(Effect.succeed(result as T));
+        }
+      },
+      (err) => {
+        if (settled || signal.aborted) return;
+        settled = true;
+        resume(Effect.die(err));
+      },
+    );
+  });
+
+export const success = (str: string) => Effect.sync(() => p.log.success(str));
+export const warn = (str: string) => Effect.sync(() => p.log.warn(str));
+export const error = (str: string) => Effect.sync(() => p.log.error(str));
+export const info = (str: string) => Effect.sync(() => p.log.info(str));
+export const text = (opts: p.TextOptions) => prompt(() => p.text(opts));
+export const password = (opts: p.PasswordOptions) =>
+  prompt(() => p.password(opts));
+export const select = <Value>(opts: p.SelectOptions<Value>) =>
+  prompt(() => p.select<Value>(opts));
+export const confirm = (opts: p.ConfirmOptions) =>
+  prompt(() => p.confirm(opts));
+export const multiselect = <Value>(opts: p.MultiSelectOptions<Value>) =>
+  prompt(() => p.multiselect<Value>(opts));
+
+/**
+ * Open a URL in the user's default browser.
+ *
+ * On Windows, uses rundll32's FileProtocolHandler — a built-in shim that
+ * opens URLs in the default browser. It accepts the URL as a direct
+ * argument (no shell, no quoting of `&`). cmd.exe `start` would treat
+ * `&` in OAuth URLs as a command separator, and `explorer.exe` treats
+ * its arg as a path.
+ */
+export const openUrl = (url: string) =>
+  Effect.gen(function* () {
+    const [cmd, args] =
+      process.platform === "win32"
+        ? (["rundll32.exe", ["url.dll,FileProtocolHandler", url]] as const)
+        : process.platform === "darwin"
+          ? (["open", [url]] as const)
+          : (["xdg-open", [url]] as const);
+    const handle = yield* ChildProcess.make(cmd, [...args], { shell: false });
+    yield* handle.exitCode;
+  }).pipe(Effect.scoped);

package/src/Util/PlatformServices.ts

@@ -0,0 +1,62 @@
+import * as Effect from "effect/Effect";
+import type { FileSystem } from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import type { Path } from "effect/Path";
+import type { Teardown } from "effect/Runtime";
+import type { Stdio } from "effect/Stdio";
+import type { Terminal } from "effect/Terminal";
+import type { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
+import type { WebSocketConstructor } from "effect/unstable/socket/Socket";
+
+const isBun = typeof Bun !== "undefined";
+
+export type PlatformServices =
+  | ChildProcessSpawner
+  | FileSystem
+  | Path
+  | Stdio
+  | Terminal
+  // WebSocketConstructor is not included in NodeServices/BunServices, but required for Workers tail
+  | WebSocketConstructor;
+
+export const PlatformServices: Layer.Layer<PlatformServices> = Effect.promise(
+  async () => {
+    if (isBun) {
+      const [BunServices, BunSocket] = await Promise.all([
+        import("@effect/platform-bun/BunServices"),
+        import("@effect/platform-bun/BunSocket"),
+      ]);
+      return Layer.merge(
+        BunServices.layer,
+        BunSocket.layerWebSocketConstructor,
+      );
+    } else {
+      const [NodeServices, NodeSocket] = await Promise.all([
+        import("@effect/platform-node/NodeServices"),
+        import("@effect/platform-node/NodeSocket"),
+      ]);
+      return Layer.merge(
+        NodeServices.layer,
+        NodeSocket.layerWebSocketConstructor,
+      );
+    }
+  },
+).pipe(Layer.unwrap);
+
+export const runMain = <E, A>(
+  effect: Effect.Effect<A, E>,
+  options?: {
+    readonly disableErrorReporting?: boolean | undefined;
+    readonly teardown?: Teardown | undefined;
+  },
+): void => {
+  if (isBun) {
+    void import("@effect/platform-bun/BunRuntime").then((BunRuntime) =>
+      BunRuntime.runMain(effect, options),
+    );
+  } else {
+    void import("@effect/platform-node/NodeRuntime").then((NodeRuntime) =>
+      NodeRuntime.runMain(effect, options),
+    );
+  }
+};

package/src/Util/dedent.ts

@@ -0,0 +1,59 @@
+/**
+ * Tagged template literal for removing indentation from a block of text.
+ *
+ * If the first line is empty, it will be ignored.
+ */
+export function dedent(
+  strings: TemplateStringsArray,
+  ...values: unknown[]
+): string;
+export function dedent(text: string): string;
+export function dedent(
+  stringsOrText: TemplateStringsArray | string,
+  ...values: unknown[]
+): string {
+  const raw =
+    typeof stringsOrText === "string"
+      ? stringsOrText
+      : String.raw({ raw: stringsOrText }, ...values);
+
+  let lines = raw.split("\n");
+
+  while (lines.length > 0 && lines[0].trim() === "") {
+    lines = lines.slice(1);
+  }
+
+  while (lines.length > 0 && lines[lines.length - 1].trim() === "") {
+    lines = lines.slice(0, lines.length - 1);
+  }
+
+  if (lines.length === 0) {
+    return "";
+  }
+
+  let minIndentLength = Number.POSITIVE_INFINITY;
+  for (const line of lines) {
+    if (line.trim() !== "") {
+      const indent = line.match(/^[ \t]*/)?.[0];
+      if (indent != null && indent.length < minIndentLength) {
+        minIndentLength = indent.length;
+      }
+    }
+  }
+
+  if (minIndentLength === Number.POSITIVE_INFINITY) {
+    return lines.join("\n");
+  }
+
+  lines = lines.map((line) => {
+    if (line.trim() === "") {
+      return line;
+    }
+    return line.startsWith(" ".repeat(minIndentLength)) ||
+      line.startsWith("\t".repeat(minIndentLength))
+      ? line.substring(minIndentLength)
+      : line;
+  });
+
+  return lines.join("\n");
+}

package/src/Util/index.ts

@@ -3,6 +3,7 @@ export * from "./base32.ts";
 export * from "./camel.ts";
 export * from "./class.ts";
 export * from "./data.ts";
+export * from "./dedent.ts";
 export * from "./instance.ts";
 export * from "./pointer.ts";
 export * from "./schema-to-type.ts";

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";