alchemy 2.0.0-beta.3 → 2.0.0-beta.test-export-fix-3

package/src/Cloudflare/Workers/Worker.ts

@@ -26,7 +26,7 @@ import { findCwdForBundle } from "../../Bundle/TempRoot.ts";
 import type { ScopedPlanStatusSession } from "../../Cli/Cli.ts";
 import { isResolved } from "../../Diff.ts";
 import type { HttpEffect } from "../../Http.ts";
-import type { Input, InputProps } from "../../Input.ts";
+import type { InputProps } from "../../Input.ts";
 import * as Output from "../../Output.ts";
 import { createPhysicalName } from "../../PhysicalName.ts";
 import {
@@ -47,10 +47,20 @@ import { fromCloudflareFetcher } from "../Fetcher.ts";
 import { CloudflareLogs } from "../Logs.ts";
 import type { Providers } from "../Providers.ts";
 import type { R2Bucket } from "../R2/R2Bucket.ts";
-import type { AssetsConfig, AssetsProps } from "./Assets.ts";
-import * as Assets from "./Assets.ts";
+import {
+  isAssets,
+  readAssets,
+  uploadAssets,
+  type Assets,
+  type AssetsConfig,
+  type AssetsProps,
+} from "./Assets.ts";
 import cloudflare_workers from "./cloudflare_workers.ts";
-import { isDurableObjectExport } from "./DurableObjectNamespace.ts";
+import {
+  isDurableObjectExport,
+  isDurableObjectNamespaceLike,
+  type DurableObjectNamespaceLike,
+} from "./DurableObjectNamespace.ts";
 import { workersHttpHandler } from "./HttpServer.ts";
 import { Request } from "./Request.ts";
 import { makeRpcStub } from "./Rpc.ts";
@@ -105,12 +115,12 @@ export interface AssetsWithHash {
   /**
    * Path to the assets directory.
    */
-  path: Input<string>;
+  path: string;
   /**
    * Pre-computed hash of the assets. When provided, this hash is used for diffing
    * to determine if the worker needs to be redeployed.
    */
-  hash: Input<string>;
+  hash: string;
   /**
    * Optional assets configuration.
    */
@@ -161,7 +171,11 @@ export type WorkerServices = Worker | WorkerEnvironment | Request;
 
 export type WorkerShape = Main<WorkerServices>;
 
-export type WorkerBindingResource = R2Bucket | D1Database;
+export type WorkerBindingResource =
+  | Assets
+  | R2Bucket
+  | D1Database
+  | DurableObjectNamespaceLike<any>;
 
 export type WorkerBindings = {
   [bindingName in string]: WorkerBindingResource;
@@ -173,8 +187,26 @@ export type WorkerBindingProps = {
     | Effect.Effect<WorkerBindingResource, any, any>;
 };
 
+type NormalizedBindings<
+  Bindings extends WorkerBindingProps = {},
+  AssetsConfig extends WorkerAssetsConfig | undefined = undefined,
+> = {
+  [B in keyof Bindings]: Bindings[B] extends Effect.Effect<
+    infer T extends WorkerBindingResource,
+    any,
+    any
+  >
+    ? T
+    : Extract<Bindings[B], WorkerBindingResource>;
+} & (undefined extends AssetsConfig ? {} : { ASSETS: Assets });
+
+export type WorkerAssetsConfig = string | AssetsProps | AssetsWithHash;
+
 export interface WorkerProps<
   Bindings extends WorkerBindingProps = any,
+  Assets extends WorkerAssetsConfig | undefined =
+    | WorkerAssetsConfig
+    | undefined,
 > extends PlatformProps {
   /**
    * Worker name override. If omitted, Alchemy derives a deterministic physical
@@ -192,11 +224,7 @@ export interface WorkerProps<
    * - An AssetsProps object with directory and config
    * - An object with path and hash (e.g., from a Build resource)
    */
-  assets?:
-    | string
-    | AssetsProps
-    | AssetsWithHash
-    | (AssetsWithHash & { [K: string]: any });
+  assets?: Assets;
   subdomain?: {
     enabled?: boolean;
     previewsEnabled?: boolean;
@@ -295,6 +323,10 @@ export type Worker<Bindings extends WorkerBindings = any> = Resource<
  * at runtime, and `Cloudflare.InferEnv` to extract a fully typed
  * `env` object from those bindings.
  *
+ * See the {@link https://alchemy.run/guides/async-worker | Async Workers Guide}
+ * for a comprehensive walkthrough of all binding types (R2, D1,
+ * Durable Objects, Assets, and more).
+ *
  * @example Defining an async Worker in your stack
  * ```typescript
  * // alchemy.run.ts
@@ -579,18 +611,18 @@ export const Worker: Platform<
   WorkerShape,
   WorkerExecutionContext
 > & {
-  <const Bindings extends WorkerBindingProps>(
+  <
+    const Bindings extends WorkerBindingProps,
+    const Assets extends WorkerAssetsConfig | undefined = undefined,
+  >(
     id: string,
-    props: InputProps<WorkerProps<Bindings>>,
+    props: InputProps<WorkerProps<Bindings, Assets>>,
   ): Effect.Effect<
     Worker<{
-      [B in keyof Bindings]: Bindings[B] extends Effect.Effect<
-        infer T extends WorkerBindingResource,
-        any,
-        any
-      >
-        ? T
-        : Extract<Bindings[B], WorkerBindingResource>;
+      [binding in keyof NormalizedBindings<
+        Bindings,
+        Assets
+      >]: NormalizedBindings<Bindings, Assets>[binding];
     }>
   >;
 } = Platform(WorkerTypeId, {
@@ -608,31 +640,45 @@ export const Worker: Platform<
           ? yield* bindingEff
           : bindingEff;
 
-        const bindingMeta: InputProps<WorkerBinding> | undefined =
-          binding.Type === "Cloudflare.D1Database"
+        const bindingMeta: InputProps<WorkerBinding> | undefined = isAssets(
+          binding,
+        )
+          ? {
+              type: "assets",
+              name: bindingName,
+            }
+          : isDurableObjectNamespaceLike(binding)
             ? {
-                type: "d1",
-                id: binding.databaseId,
+                type: "durable_object_namespace",
                 name: bindingName,
+                className: binding.className ?? binding.name,
               }
-            : binding.Type === "Cloudflare.R2Bucket"
+            : binding.Type === "Cloudflare.D1Database"
               ? {
-                  type: "r2_bucket",
+                  type: "d1",
+                  id: binding.databaseId,
                   name: bindingName,
-                  bucketName: binding.bucketName,
-                  jurisdiction: binding.jurisdiction.pipe(
-                    Output.map((jurisdiction) =>
-                      jurisdiction === "default" ? undefined : jurisdiction,
-                    ),
-                  ),
                 }
-              : // TODO(sam): handle others
-                undefined;
+              : binding.Type === "Cloudflare.R2Bucket"
+                ? {
+                    type: "r2_bucket",
+                    name: bindingName,
+                    bucketName: binding.bucketName,
+                    jurisdiction: binding.jurisdiction.pipe(
+                      Output.map((jurisdiction) =>
+                        jurisdiction === "default" ? undefined : jurisdiction,
+                      ),
+                    ),
+                  }
+                : // TODO(sam): handle others
+                  undefined;
 
         if (bindingMeta) {
           yield* resource.bind`${bindingName}`({
             bindings: [bindingMeta],
           });
+        } else {
+          return yield* Effect.die(`Unknown binding type: ${bindingName}`);
         }
       }
     }
@@ -857,7 +903,6 @@ export const WorkerProvider = () =>
       const virtualEntryPlugin = yield* Bundle.virtualEntryPlugin;
       const stack = yield* Stack;
 
-      const { read, upload } = yield* Assets.Assets;
       const createScriptSubdomain = yield* workers.createScriptSubdomain;
       const createScriptTail = yield* workers.createScriptTail;
       const deleteScript = yield* workers.deleteScript;
@@ -974,7 +1019,9 @@ export const WorkerProvider = () =>
       const prepareAssets = Effect.fnUntraced(function* (
         assets: WorkerProps["assets"],
       ) {
-        if (!assets) return undefined;
+        if (!assets) {
+          return undefined;
+        }
 
         // Handle AssetsWithHash (from Build resource)
         // Props are resolved by Plan, so Input<string> values are already strings at runtime
@@ -983,7 +1030,7 @@ export const WorkerProvider = () =>
           "path" in assets &&
           "hash" in assets
         ) {
-          const result = yield* read({
+          const result = yield* readAssets({
             directory: assets.path as string,
             config: assets.config,
           });
@@ -994,7 +1041,7 @@ export const WorkerProvider = () =>
         }
 
         // Handle string path or AssetsProps
-        return yield* read(
+        return yield* readAssets(
           typeof assets === "string" ? { directory: assets } : assets,
         );
       });
@@ -1065,8 +1112,8 @@ import * as Stream from "effect/Stream";
 import { env, DurableObject${hasWfClasses ? ", WorkflowEntrypoint" : ""} } from "cloudflare:workers";
 import { MinimumLogLevel } from "effect/References";
 import { NodeServices } from "@effect/platform-node";
-import { Stack } from "alchemy-effect/Stack";
-import { WorkerEnvironment, makeDurableObjectBridge${hasWfClasses ? ", makeWorkflowBridge" : ""}, ExportedHandlerMethods } from "alchemy-effect/Cloudflare";
+import { Stack } from "alchemy/Stack";
+import { WorkerEnvironment, makeDurableObjectBridge${hasWfClasses ? ", makeWorkflowBridge" : ""}, ExportedHandlerMethods } from "alchemy/Cloudflare";
 
 import entry from "${importPath}";
 
@@ -1232,7 +1279,7 @@ ${[
         const [assets, bundle] = yield* Effect.all(
           [
             assetsDirectory
-              ? read({
+              ? readAssets({
                   directory: assetsDirectory,
                   config:
                     typeof props.assets === "object" && "config" in props.assets
@@ -1312,7 +1359,12 @@ ${[
             yield* Effect.logInfo(
               `Cloudflare Worker ${olds ? "update" : "create"}: uploading assets for ${name}`,
             );
-            const { jwt } = yield* upload(accountId, name, assets, session);
+            const { jwt } = yield* uploadAssets(
+              accountId,
+              name,
+              assets,
+              session,
+            );
             metadataAssets = {
               jwt,
               config: assets.config,

package/src/Cloudflare/Workers/index.ts

@@ -1,12 +1,15 @@
 export * from "./Assets.ts";
 export * from "./ConfigProvider.ts";
 export * from "./DurableObjectNamespace.ts";
+export * from "./DurableObjectState.ts";
+export * from "./DurableObjectStorage.ts";
 export * from "./DynamicWorkerLoader.ts";
 export * from "./Fetch.ts";
 export * from "./HttpServer.ts";
 export * from "./InferEnv.ts";
 export * from "./Request.ts";
 export * from "./Rpc.ts";
+export * from "./ScheduledEvents.ts";
 export * from "./WebSocket.ts";
 export * from "./Worker.ts";
 export * from "./Workflow.ts";

package/src/Construct.ts

@@ -12,8 +12,8 @@ import * as Namespace from "./Namespace.ts";
  * @section Creating Constructs
  * @example Simple Reusable Construct
  * ```typescript
- * import * as Construct from "alchemy-effect/Construct";
- * import { Bucket } from "alchemy-effect/AWS/S3";
+ * import * as Construct from "alchemy/Construct";
+ * import { Bucket } from "alchemy/AWS/S3";
  *
  * export const Logs = Construct.fn(function* (
  *   id: string,

package/src/GitHub/Secret.ts

@@ -53,11 +53,19 @@ export interface Secret extends Resource<
 /**
  * A GitHub Actions repository or environment secret.
  *
+ * `Secret` manages the lifecycle of an encrypted secret in GitHub Actions.
  * Secrets are encrypted using the repository's (or environment's) public
- * key before being stored. The resource is idempotent — calling it with
- * the same name will update the secret value in place.
+ * key via `libsodium` before being stored. The resource is idempotent —
+ * calling it with the same name will update the secret value in place.
+ *
+ * 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 Secrets
+ * Store secrets accessible to all GitHub Actions workflows in the
+ * repository.
+ *
  * @example Create a Repository Secret
  * ```typescript
  * yield* GitHub.Secret("aws-role", {
@@ -69,6 +77,10 @@ export interface Secret extends Resource<
  * ```
  *
  * @section Environment Secrets
+ * Scope a secret to a specific GitHub Actions environment (e.g.
+ * `production`, `staging`). Environment secrets require environment
+ * protection rules to be satisfied before workflows can access them.
+ *
  * @example Create an Environment Secret
  * ```typescript
  * yield* GitHub.Secret("deploy-key", {
@@ -79,6 +91,42 @@ export interface Secret extends Resource<
  *   value: Redacted.make("my-secret-value"),
  * });
  * ```
+ *
+ * @section Wiring with Other Resources
+ * A common pattern is wiring the output of another resource — like an
+ * IAM role ARN or a database URL — directly into a GitHub secret so
+ * that CI workflows can use it.
+ *
+ * @example Store an IAM Role ARN for CI
+ * ```typescript
+ * const role = yield* AWS.IAM.Role("ci-role", { ... });
+ *
+ * yield* GitHub.Secret("ci-role-arn", {
+ *   owner: "my-org",
+ *   repository: "my-repo",
+ *   name: "AWS_ROLE_ARN",
+ *   value: Redacted.make(role.roleArn),
+ * });
+ * ```
+ *
+ * @example Store Multiple Secrets
+ * ```typescript
+ * yield* GitHub.Secret("db-url", {
+ *   owner: "my-org",
+ *   repository: "my-repo",
+ *   environment: "production",
+ *   name: "DATABASE_URL",
+ *   value: Redacted.make(database.connectionString),
+ * });
+ *
+ * yield* GitHub.Secret("api-key", {
+ *   owner: "my-org",
+ *   repository: "my-repo",
+ *   environment: "production",
+ *   name: "API_KEY",
+ *   value: Redacted.make(apiKey),
+ * });
+ * ```
  */
 export const Secret = Resource<Secret>("GitHub.Secret");
 
@@ -98,10 +146,7 @@ async function encryptValue(
 ): Promise<string> {
   const sodium = await import("libsodium-wrappers");
   await sodium.ready;
-  const binKey = sodium.from_base64(
-    publicKey,
-    sodium.base64_variants.ORIGINAL,
-  );
+  const binKey = sodium.from_base64(publicKey, sodium.base64_variants.ORIGINAL);
   const binMessage = sodium.from_string(plaintext);
   const encrypted = sodium.crypto_box_seal(binMessage, binKey);
   return sodium.to_base64(encrypted, sodium.base64_variants.ORIGINAL);
@@ -115,7 +160,7 @@ export const SecretProvider = () =>
       return { updatedAt: new Date().toISOString() };
     }),
 
-    update: Effect.fn(function* ({ news, olds, output }) {
+    update: Effect.fn(function* ({ news, olds }) {
       const octokit = createClient(news);
 
       const wasEnv = !!olds.environment;

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

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/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,