alchemy 2.0.0-beta.21 → 2.0.0-beta.23

package/src/AWS/Lambda/Function.ts

@@ -23,6 +23,7 @@ import { Platform, type Main, type PlatformProps } from "../../Platform.ts";
 import type { LogLine, LogsInput } from "../../Provider.ts";
 import * as Provider from "../../Provider.ts";
 import { Resource, type ResourceBinding } from "../../Resource.ts";
+import { Self } from "../../Self.ts";
 import * as Serverless from "../../Serverless/index.ts";
 import { Stack } from "../../Stack.ts";
 import { createInternalTags, createTagsList, hasTags } from "../../Tags.ts";
@@ -617,7 +618,6 @@ export const FunctionProvider = () =>
               cwd,
               external: [
                 /^@aws-sdk\//,
-                /^@smithy\//,
                 ...((props.build?.input?.external as string[]) ?? []),
               ],
               platform: "node",
@@ -627,8 +627,9 @@ export const FunctionProvider = () =>
               ...props.build?.output,
               format: "esm",
               sourcemap: rolldownSourcemap,
-              minify: props.build?.output?.minify ?? true,
+              minify: props.build?.output?.minify ?? false,
               entryFileNames: "index.js",
+              codeSplitting: props.build?.output?.codeSplitting ?? false,
             },
           );
         });
@@ -639,30 +640,34 @@ export const FunctionProvider = () =>
               realMain,
               virtualEntryPlugin(
                 (importPath) => `
-import { NodeServices } from "@effect/platform-node";
+import { layer as nodeServicesLayer } from "@effect/platform-node/NodeServices";
 import { Stack } from "alchemy/Stack";
 import * as Config from "effect/Config";
 import * as ConfigProvider from "effect/ConfigProvider";
 import * as Credentials from "@distilled.cloud/aws/Credentials";
 import * as Effect from "effect/Effect";
-import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+import { layer as fetchHttpClientLayer } from "effect/unstable/http/FetchHttpClient";
 import * as Layer from "effect/Layer";
 import * as Logger from "effect/Logger";
 import * as Region from "@distilled.cloud/aws/Region";
 import * as Context from "effect/Context";
 import { MinimumLogLevel } from "effect/References";
 
-import { ${handler} as layer } from "${importPath}";
+import entry from "${importPath}";
+
+const tag = Context.Service("${Self.key}")
+const layer =
+  typeof entry?.build === "function"
+    ? entry
+    : Layer.effect(tag, typeof entry?.asEffect === "function" ? entry.asEffect() : entry);
 
 const platform = Layer.mergeAll(
-  NodeServices.layer,
-  FetchHttpClient.layer,
+  nodeServicesLayer,
+  fetchHttpClientLayer,
   // TODO(sam): wire this up to telemetry more directly
   Logger.layer([Logger.consolePretty()]),
 );
 
-const tag = Context.Service("${FunctionTypeId}<${id}>")
-
 const stack = Layer.effect(
   Stack,
   Effect.all([
@@ -679,7 +684,8 @@ const stack = Layer.effect(
 );
 
 const handlerEffect = tag.asEffect().pipe(
-  Effect.flatMap(func => func.ExecutionContext.exports.handler),
+  Effect.flatMap(func => func.ExecutionContext.exports),
+  Effect.flatMap(exports => exports.handler),
   Effect.provide(
     layer.pipe(
       Layer.provideMerge(stack),
@@ -714,23 +720,23 @@ export default await Effect.runPromise(handlerEffect)
             ? new TextEncoder().encode(mainFile.content)
             : mainFile.content;
 
-        const sourceMapFile =
-          uploadSourceMap && (sourcemap === true || sourcemap === "hidden")
-            ? bundleOutput.files.find((f: Bundle.BundleFile) =>
-                f.path.endsWith(".map"),
-              )
-            : undefined;
+        const includeSourceMaps =
+          uploadSourceMap && (sourcemap === true || sourcemap === "hidden");
+
+        const extraFiles = bundleOutput.files
+          .slice(1)
+          .filter(
+            (f: Bundle.BundleFile) =>
+              includeSourceMaps || !f.path.endsWith(".map"),
+          )
+          .map((f: Bundle.BundleFile) => ({
+            path: f.path,
+            content: f.content,
+          }));
 
         const archive = yield* zipCode(
           code,
-          sourceMapFile
-            ? [
-                {
-                  path: sourceMapFile.path,
-                  content: sourceMapFile.content,
-                },
-              ]
-            : undefined,
+          extraFiles.length > 0 ? extraFiles : undefined,
         );
         return {
           archive,

package/src/AWS/Lambda/HttpServer.ts

@@ -19,7 +19,9 @@ export const makeFunctionHttpHandler = <Req>(handler: Http.HttpEffect<Req>) => {
   const safeHandler = Http.safeHttpEffect(handler);
   return (event: any) => {
     if (isFunctionURLEvent(event)) {
-      const request = HttpServerRequest.fromWeb(toWebRequest(event)).modify({
+      const webRequest = toWebRequest(event);
+      const request = HttpServerRequest.fromWeb(webRequest).modify({
+        url: webRequest.url,
         remoteAddress: Option.some(event.requestContext.http.sourceIp),
       });
       return safeHandler.pipe(

package/src/Cloudflare/Container/Container.ts

@@ -118,8 +118,10 @@ export type Container = {
  * @section Configuration
  * The props object accepts `main` (entrypoint file), `instanceType`
  * (compute size), `runtime` (`"bun"` or `"node"`), and
- * `observability` settings. Use `Stack.useSync` to vary config by
- * stage.
+ * `observability` settings. Use `Stack.useSync` to read the
+ * surrounding stack at declaration time and pick a beefier
+ * `instanceType` in prod while keeping the cheap `dev` instance for
+ * preview environments.
  *
  * @example Stage-dependent configuration
  * ```typescript
@@ -133,6 +135,57 @@ export type Container = {
  * ) {}
  * ```
  *
+ * @section Stack-level wiring
+ * The `.make()` `export default` is the side-effect that registers
+ * the container's runtime. It must be reachable from your
+ * `alchemy.run.ts` so the bundler emits the runtime entrypoint.
+ * Provide it on the Stack's generator with `Effect.provide`.
+ *
+ * @example Wiring SandboxLive into the Stack
+ * ```typescript
+ * // alchemy.run.ts
+ * import SandboxLive from "./src/Sandbox.runtime.ts";
+ *
+ * export default Alchemy.Stack(
+ *   "MyApp",
+ *   { providers: Cloudflare.providers(), state: Cloudflare.state() },
+ *   Effect.gen(function* () {
+ *     const worker = yield* Worker;
+ *     return { url: worker.url };
+ *   }).pipe(Effect.provide(SandboxLive)),
+ * );
+ * ```
+ *
+ * @section Calling from a Durable Object
+ * Use `Cloudflare.Container.bind(Sandbox)` in the **outer** init
+ * phase of a Durable Object — only the class is imported, so the
+ * DO bundle stays tiny. Then `Cloudflare.start(sandbox)` in the
+ * **inner** per-instance phase ensures the container is running
+ * and gives you a typed handle that exposes every method declared
+ * on the container's shape **plus** a `getTcpPort` helper.
+ *
+ * @example Binding and starting a container from a DO
+ * ```typescript
+ * export default class Agent extends Cloudflare.DurableObjectNamespace<Agent>()(
+ *   "Agents",
+ *   Effect.gen(function* () {
+ *     // OUTER (init): only the class is referenced — the runtime
+ *     // implementation in `Sandbox.runtime.ts` is tree-shaken out
+ *     // of this DO's bundle.
+ *     const sandbox = yield* Cloudflare.Container.bind(Sandbox);
+ *
+ *     return Effect.gen(function* () {
+ *       // INNER (per-instance): start the container and expose RPC.
+ *       const container = yield* Cloudflare.start(sandbox);
+ *
+ *       return {
+ *         exec: (cmd: string) => container.exec(cmd),
+ *       };
+ *     });
+ *   }),
+ * ) {}
+ * ```
+ *
  * @section Starting from a Durable Object
  * Use `Cloudflare.Container.bind` in the outer init phase to bind
  * the container class, then `Cloudflare.start` in the inner

package/src/Cloudflare/D1/D1Clone.ts

@@ -0,0 +1,42 @@
+import * as Effect from "effect/Effect";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import * as HttpClientRequest from "effect/unstable/http/HttpClientRequest";
+import { exportD1Database } from "./D1Export.ts";
+import { importD1Database } from "./D1Import.ts";
+
+export interface CloneD1DatabaseOptions {
+  accountId: string;
+  sourceDatabaseId: string;
+  targetDatabaseId: string;
+}
+
+/**
+ * Clone a D1 database by exporting from the source and importing into the
+ * target. Fetches the SQL dump from the export's signed URL and streams the
+ * payload through the import flow.
+ */
+export const cloneD1Database = (options: CloneD1DatabaseOptions) =>
+  Effect.gen(function* () {
+    const exportResult = yield* exportD1Database({
+      accountId: options.accountId,
+      databaseId: options.sourceDatabaseId,
+    });
+
+    const client = yield* HttpClient.HttpClient;
+    const dumpRes = yield* client
+      .execute(HttpClientRequest.get(exportResult.signedUrl))
+      .pipe(Effect.orDie);
+    if (dumpRes.status < 200 || dumpRes.status >= 300) {
+      return yield* Effect.die(
+        `Failed to fetch D1 export dump (${dumpRes.status})`,
+      );
+    }
+    const sqlData = yield* dumpRes.text.pipe(Effect.orDie);
+
+    return yield* importD1Database({
+      accountId: options.accountId,
+      databaseId: options.targetDatabaseId,
+      sqlData,
+      filename: exportResult.filename,
+    });
+  });