alchemy 2.0.0-beta.3 → 2.0.0-beta.4

package/src/GitHub/Variable.ts

@@ -45,10 +45,20 @@ export interface Variable extends Resource<
 /**
  * A GitHub Actions repository variable.
  *
- * Variables are stored in plain text and are suitable for non-sensitive
- * configuration like region names or role ARNs.
+ * `Variable` manages the lifecycle of a plain-text configuration variable
+ * in GitHub Actions. Variables are visible in workflow logs and are
+ * suitable for non-sensitive configuration like region names, environment
+ * labels, or feature flags. For sensitive values, use `GitHub.Secret`
+ * instead.
+ *
+ * Authentication is resolved in order: explicit `token` prop,
+ * `GITHUB_ACCESS_TOKEN` env var, `GITHUB_TOKEN` env var. The token needs
+ * `repo` scope for private repositories or `public_repo` for public ones.
  *
  * @section Repository Variables
+ * Store variables accessible to all GitHub Actions workflows in the
+ * repository.
+ *
  * @example Create a Repository Variable
  * ```typescript
  * yield* GitHub.Variable("aws-region", {
@@ -58,6 +68,39 @@ export interface Variable extends Resource<
  *   value: "us-east-1",
  * });
  * ```
+ *
+ * @section Wiring with Other Resources
+ * Pass output attributes from other resources into GitHub variables so
+ * that CI workflows can reference them.
+ *
+ * @example Store a Worker URL for CI
+ * ```typescript
+ * const worker = yield* Cloudflare.Worker("Api", { ... });
+ *
+ * yield* GitHub.Variable("api-url", {
+ *   owner: "my-org",
+ *   repository: "my-repo",
+ *   name: "API_URL",
+ *   value: worker.url!,
+ * });
+ * ```
+ *
+ * @example Multiple Variables
+ * ```typescript
+ * yield* GitHub.Variable("region", {
+ *   owner: "my-org",
+ *   repository: "my-repo",
+ *   name: "AWS_REGION",
+ *   value: "us-east-1",
+ * });
+ *
+ * yield* GitHub.Variable("stage", {
+ *   owner: "my-org",
+ *   repository: "my-repo",
+ *   name: "DEPLOY_STAGE",
+ *   value: "production",
+ * });
+ * ```
  */
 export const Variable = Resource<Variable>("GitHub.Variable");
 

package/src/Kubernetes/client.ts

@@ -1,6 +1,6 @@
-import { AwsClient } from "aws4fetch";
 import { Credentials } from "@distilled.cloud/aws/Credentials";
 import { Region } from "@distilled.cloud/aws/Region";
+import { AwsClient } from "aws4fetch";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Redacted from "effect/Redacted";
@@ -28,7 +28,7 @@ export interface KubernetesClusterConnection {
   certificateAuthorityData: string;
 }
 
-const fieldManager = "alchemy-effect";
+const fieldManager = "alchemy";
 
 const createBearerToken = Effect.fn(function* (clusterName: string) {
   const credentials = yield* yield* Credentials;

package/src/Output.ts

@@ -90,7 +90,7 @@ export abstract class BaseExpr<A = any, Req = any> implements Output<A, Req> {
   declare readonly A: A;
   declare readonly src: ResourceLike;
   declare readonly req: Req;
-  // we use a kind tag instead of instanceof to protect ourselves from duplicate alchemy-effect module imports
+  // we use a kind tag instead of instanceof to protect ourselves from duplicate alchemy module imports
   constructor() {}
   as<T>(): Output<T, Req> {
     return this as any;

package/src/Platform.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
@@ -220,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/Resource.ts

@@ -31,10 +31,10 @@ 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<

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";
@@ -44,6 +44,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 = () =>
@@ -90,7 +91,7 @@ const quietLogger = Logger.make(() => {
 });
 
 const platform = Layer.mergeAll(
-  NodeServices.layer,
+  PlatformServices,
   FetchHttpClient.layer,
   Logger.layer([process.env.VERBOSE ? Logger.consolePretty() : quietLogger]),
 );
@@ -212,7 +213,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,21 @@
+import type { BunServices } from "@effect/platform-bun/BunServices";
+import type { NodeServices } from "@effect/platform-node/NodeServices";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+
+const isBun = typeof Bun !== "undefined";
+
+export const PlatformServices: Layer.Layer<
+  NodeServices | BunServices,
+  never,
+  never
+> = Effect.promise(() => {
+  if (isBun) {
+    return import("@effect/platform-bun").then(
+      (platform) => platform.BunServices.layer,
+    );
+  }
+  return import("@effect/platform-node").then(
+    (platform) => platform.NodeServices.layer,
+  );
+}).pipe(Layer.unwrap);

package/src/Util/dedent.ts

@@ -3,7 +3,10 @@
  *
  * If the first line is empty, it will be ignored.
  */
-export function dedent(strings: TemplateStringsArray, ...values: unknown[]): string;
+export function dedent(
+  strings: TemplateStringsArray,
+  ...values: unknown[]
+): string;
 export function dedent(text: string): string;
 export function dedent(
   stringsOrText: TemplateStringsArray | string,