alchemy 2.0.0-beta.34 → 2.0.0-beta.36

package/src/Cloudflare/Workers/WorkerBundle.ts

@@ -4,7 +4,9 @@ import * as FileSystem from "effect/FileSystem";
 import { flow } from "effect/Function";
 import type * as Path from "effect/Path";
 import * as Stream from "effect/Stream";
+import { fileURLToPath } from "node:url";
 import type * as rolldown from "rolldown";
+import Sonda from "sonda/rolldown";
 import * as Artifacts from "../../Artifacts.ts";
 import * as Bundle from "../../Bundle/Bundle.ts";
 import { findCwdForBundle } from "../../Bundle/TempRoot.ts";
@@ -13,6 +15,7 @@ import {
   isDurableObjectExport,
   type DurableObjectExport,
 } from "./DurableObjectNamespace.ts";
+import type { WorkerProps } from "./Worker.ts";
 import { isWorkflowExport, type WorkflowExport } from "./Workflow.ts";
 
 export interface WorkerBundleOptions {
@@ -31,6 +34,7 @@ export interface WorkerBundleOptions {
         exports: Record<string, DurableObjectExport | WorkflowExport>;
       };
   stack: { name: string; stage: string };
+  userOptions: WorkerProps["build"] | undefined;
 }
 
 export const WorkerBundle = Effect.gen(function* () {
@@ -41,15 +45,7 @@ export const WorkerBundle = Effect.gen(function* () {
   const makeOptions = Effect.fnUntraced(function* (
     options: WorkerBundleOptions,
   ) {
-    const realMain = yield* fs.realPath(options.main).pipe(
-      Effect.mapError(
-        (cause) =>
-          new Bundle.BundleError({
-            message: `Failed to find real path for bundle: ${options.main}`,
-            cause,
-          }),
-      ),
-    );
+    const realMain = yield* sanitizeMain(options.main);
     const inputOptions: rolldown.InputOptions = {
       input: realMain,
       cwd: yield* findCwdForBundle(realMain).pipe(
@@ -72,6 +68,7 @@ export const WorkerBundle = Effect.gen(function* () {
               makeEffectVirtualEntry(options.entry.exports, options.stack),
             )
           : undefined,
+        ...(options.userOptions?.metafile ? [Sonda({ open: false })] : []),
       ],
       checks: {
         // Suppress unresolved import warnings for unrelated AWS packages
@@ -85,14 +82,39 @@ export const WorkerBundle = Effect.gen(function* () {
       keepNames: true,
       dir: `.alchemy/bundles/${options.id}`,
     };
-    return { inputOptions, outputOptions };
+    const extraOptions: Bundle.BundleExtraOptions = {
+      pure: options.userOptions?.pure,
+    };
+    return { inputOptions, outputOptions, extraOptions };
   });
 
+  const sanitizeMain = (main: string) =>
+    Effect.sync(() => {
+      try {
+        return fileURLToPath(main);
+      } catch {
+        return main;
+      }
+    }).pipe(
+      Effect.flatMap((path) => fs.realPath(path)),
+      Effect.mapError(
+        (cause) =>
+          new Bundle.BundleError({
+            message: `Failed to find real path for bundle: ${main}`,
+            cause,
+          }),
+      ),
+    );
+
   return {
     build: flow(
       makeOptions,
       Effect.flatMap((resolved) =>
-        Bundle.build(resolved.inputOptions, resolved.outputOptions),
+        Bundle.build(
+          resolved.inputOptions,
+          resolved.outputOptions,
+          resolved.extraOptions,
+        ),
       ),
       Artifacts.cached("build"),
     ),
@@ -100,7 +122,11 @@ export const WorkerBundle = Effect.gen(function* () {
       makeOptions,
       Stream.fromEffect,
       Stream.flatMap((resolved) =>
-        Bundle.watch(resolved.inputOptions, resolved.outputOptions),
+        Bundle.watch(
+          resolved.inputOptions,
+          resolved.outputOptions,
+          resolved.extraOptions,
+        ),
       ),
     ),
   };

package/src/Cloudflare/Zone.ts

@@ -0,0 +1,88 @@
+import {
+  Credentials,
+  formatHeaders,
+} from "@distilled.cloud/cloudflare/Credentials";
+import * as Effect from "effect/Effect";
+
+export type ZoneReference = string | { zoneId: string; name?: string };
+
+export const isZoneId = (zone: string): boolean => /^[a-f0-9]{32}$/i.test(zone);
+
+export const matchesZoneHostname = (
+  zoneName: string,
+  hostname: string,
+): boolean => hostname === zoneName || hostname.endsWith(`.${zoneName}`);
+
+export const resolveZoneId = ({
+  accountId,
+  zone,
+  hostname,
+}: {
+  accountId: string;
+  zone: ZoneReference | undefined;
+  hostname: string;
+}) =>
+  Effect.gen(function* () {
+    if (typeof zone === "object") return zone.zoneId;
+    if (typeof zone === "string" && isZoneId(zone)) return zone;
+
+    const lookup = zone ?? hostname;
+    for (const candidate of zoneNameCandidates(lookup)) {
+      const match = yield* findZoneByName({ accountId, name: candidate });
+      if (match) return match.id;
+    }
+    return yield* Effect.fail(
+      new Error(`Cloudflare zone not found for ${lookup}`),
+    );
+  });
+
+type ZoneListResponse = {
+  success: boolean;
+  errors?: { message?: string }[];
+  result?: { id: string; name: string; account: { id?: string | null } }[];
+};
+
+const findZoneByName = ({
+  accountId,
+  name,
+}: {
+  accountId: string;
+  name: string;
+}) =>
+  Effect.gen(function* () {
+    const credentialsEffect = yield* Credentials;
+    const credentials = yield* credentialsEffect;
+    const url = new URL(`${credentials.apiBaseUrl}/zones`);
+    url.searchParams.set("account.id", accountId);
+    url.searchParams.set("name", name);
+    url.searchParams.set("per_page", "1");
+
+    const json = yield* Effect.tryPromise({
+      try: async () => {
+        const response = await fetch(url, {
+          headers: formatHeaders(credentials),
+        });
+        return (await response.json()) as ZoneListResponse;
+      },
+      catch: (cause) => new Error(`Failed to list Cloudflare zones`, { cause }),
+    });
+
+    if (!json.success) {
+      return yield* Effect.fail(
+        new Error(
+          json.errors?.map((error) => error.message).join(", ") ??
+            `Failed to list Cloudflare zones`,
+        ),
+      );
+    }
+
+    return json.result?.find(
+      (candidate) =>
+        candidate.name === name && candidate.account.id === accountId,
+    );
+  });
+
+const zoneNameCandidates = (hostname: string): string[] => {
+  const parts = hostname.split(".");
+  return parts.slice(0, -1).map((_, index) => parts.slice(index).join("."));
+};

package/src/Cloudflare/index.ts

@@ -6,6 +6,7 @@ export * from "./Container/index.ts";
 export * from "./D1/index.ts";
 export * from "./EdgeSession.ts";
 export * from "./Hyperdrive/index.ts";
+export * from "./Images/index.ts";
 export * from "./KV/index.ts";
 export * from "./Providers.ts";
 export * from "./Queue/index.ts";

package/src/Drizzle/Schema.ts

@@ -170,10 +170,12 @@ export const SchemaProvider = () =>
         });
 
       /**
-       * Generate a new migration directory if the schema has drifted from
-       * the latest snapshot. Returns the new state regardless.
+       * Run drizzle-kit's diff against the latest stored snapshot and
+       * return whether any SQL statements would be emitted. Used by both
+       * `diff` (to decide whether the resource actually needs an update)
+       * and `regenerate` (to decide whether to write a new migration dir).
        */
-      const regenerate = (props: SchemaProps) =>
+      const detectDrift = (props: SchemaProps) =>
         Effect.gen(function* () {
           const out = resolveOut(props);
           const dialect = props.dialect ?? "postgres";
@@ -203,6 +205,16 @@ export const SchemaProvider = () =>
             catch: (cause) =>
               new Error(`drizzle-kit generateMigration failed: ${cause}`),
           });
+          return { out, cur, prevEntry, sqlStatements };
+        });
+
+      /**
+       * Generate a new migration directory if the schema has drifted from
+       * the latest snapshot. Returns the new state regardless.
+       */
+      const regenerate = (props: SchemaProps) =>
+        Effect.gen(function* () {
+          const { out, cur, sqlStatements } = yield* detectDrift(props);
 
           if (sqlStatements.length > 0) {
             yield* fs.makeDirectory(out, { recursive: true });
@@ -231,8 +243,12 @@ export const SchemaProvider = () =>
         diff: Effect.fn(function* ({ news, output }) {
           if (!isResolved(news)) return undefined;
           if (!output) return undefined;
-          // Force `update` so the provider runs `regenerate` on every deploy.
-          // `regenerate` itself is a no-op when nothing has drifted.
+          // Only flag an update when drizzle-kit would emit new SQL —
+          // otherwise downstream resources (e.g. Neon.Branch) would see
+          // `schema.out` as an unresolved Output during plan and cascade
+          // into spurious updates of their own.
+          const { sqlStatements } = yield* detectDrift(news);
+          if (sqlStatements.length === 0) return undefined;
           return { action: "update" } as const;
         }),
         read: Effect.fn(function* ({ olds, output }) {