alchemy 0.45.6 → 0.46.1

package/src/cloudflare/hyperdrive.ts

@@ -8,7 +8,7 @@ import { createCloudflareApi, type CloudflareApiOptions } from "./api.ts";
 import type { Bound } from "./bound.ts";
 
 /**
- * Origin configuration for a PostgreSQL database connection
+ * Origin configuration for a PostgreSQL or MySQL database connection
  */
 export interface HyperdriveOrigin {
   /**
@@ -29,7 +29,7 @@ export interface HyperdriveOrigin {
 
   /**
    * Database port
-   * @default 5432
+   * @default 5432 for postgres, 3306 for mysql
    */
   port?: number;
 
@@ -37,7 +37,7 @@ export interface HyperdriveOrigin {
    * Connection scheme
    * @default "postgres"
    */
-  scheme?: "postgres";
+  scheme?: "postgres" | "mysql";
 
   /**
    * Database user
@@ -72,7 +72,7 @@ export interface HyperdriveOriginWithAccess {
 
   /**
    * Database port
-   * @default 5432
+   * @default 5432 for postgres, 3306 for mysql
    */
   port?: number;
 
@@ -80,7 +80,7 @@ export interface HyperdriveOriginWithAccess {
    * Connection scheme
    * @default "postgres"
    */
-  scheme?: "postgres";
+  scheme?: "postgres" | "mysql";
 
   /**
    * Database user
@@ -200,6 +200,20 @@ export type Hyperdrive = HyperdriveResource & Bound<HyperdriveResource>;
  * });
  *
  * @example
+ * // Create a basic Hyperdrive connection to a MySQL database
+ * const mysqlHyperdrive = await Hyperdrive("my-mysql-db", {
+ *   name: "my-mysql-db",
+ *   origin: {
+ *     database: "mydb",
+ *     host: "mysql.example.com",
+ *     password: alchemy.secret("your-password"),
+ *     port: 3306,
+ *     scheme: "mysql",
+ *     user: "mysql_user"
+ *   }
+ * });
+ *
+ * @example
  * // Create a Hyperdrive with caching disabled
  * const noCacheHyperdrive = await Hyperdrive("no-cache-db", {
  *   name: "no-cache-db",

package/src/cloudflare/images.ts

@@ -1,5 +1,25 @@
 /**
- * Cloudflare Images binding for image transformation and manipulation.
+ * Properties for creating an Images binding
+ */
+export interface ImagesProps {
+  dev?: {
+    /**
+     * Whether to run the images binding remotely instead of locally
+     * @default false
+     */
+    remote?: boolean;
+  };
+}
+
+export type Images = {
+  type: "images";
+  dev?: {
+    remote?: boolean;
+  };
+};
+
+/**
+ * Creates a Cloudflare Images binding for image transformation and manipulation.
  *
  * Provides access to Cloudflare Images API for transforming, drawing, and outputting images
  * within Workers. The binding requires no configuration - just the binding name.
@@ -9,10 +29,11 @@
  * - For deployed Workers: image transforms must be enabled for the zone
  *
  * @example
+ * ```ts
  * // Create an Images binding and bind to a Worker:
  * import { Worker, Images } from "alchemy/cloudflare";
  *
- * const images = new Images();
+ * const images = Images();
  *
  * const worker = await Worker("image-processor", {
  *   name: "image-processor",
@@ -21,8 +42,10 @@
  *     IMAGES: images
  *   }
  * });
+ * ```
  *
  * @example
+ * ```ts
  * // Runtime usage - Basic image transformation:
  * export default {
  *   async fetch(request: Request, env: any): Promise<Response> {
@@ -36,8 +59,10 @@
  *     return response.response();
  *   }
  * };
+ * ```
  *
  * @example
+ * ```ts
  * // Runtime usage - Advanced transformations with overlays:
  * const watermark: ReadableStream = await fetchWatermark();
  * const image: ReadableStream = await fetchMainImage();
@@ -51,23 +76,13 @@
  *   .output({ format: "image/avif" });
  *
  * return response.response();
+ * ```
  *
  * @see https://developers.cloudflare.com/images/transform-images/bindings/
  */
-export class Images {
-  public readonly type = "images";
-  public readonly dev?: {
-    remote?: boolean;
+export function Images(props?: ImagesProps): Images {
+  return {
+    type: "images",
+    dev: props?.dev,
   };
-  constructor(props?: {
-    dev?: {
-      /**
-       * Whether to run the images binding remotely instead of locally
-       * @default false
-       */
-      remote?: boolean;
-    };
-  }) {
-    this.dev = props?.dev;
-  }
 }

package/src/cloudflare/index.ts

@@ -18,10 +18,8 @@ export * from "./d1-clone.ts";
 export * from "./d1-database.ts";
 export * from "./d1-export.ts";
 export * from "./d1-import.ts";
-export * from "./d1-state-store.ts";
 export * from "./dispatch-namespace.ts";
 export * from "./dns-records.ts";
-export * from "./do-state-store/index.ts";
 export * from "./durable-object-namespace.ts";
 export * from "./email-address.ts";
 export * from "./email-catch-all.ts";
@@ -37,7 +35,6 @@ export * from "./permission-groups.ts";
 export * from "./pipeline.ts";
 export * from "./queue-consumer.ts";
 export * from "./queue.ts";
-export * from "./r2-rest-state-store.ts";
 export * from "./react-router.ts";
 export * from "./redirect-rule.ts";
 export * from "./redwood.ts";
@@ -45,6 +42,7 @@ export * from "./route.ts";
 export * from "./secret-key.ts";
 export * from "./secret.ts";
 export * from "./secrets-store.ts";
+export * from "./state.ts";
 export * from "./sveltekit.ts";
 export * from "./tanstack-start.ts";
 export * from "./vectorize-index.ts";

package/src/cloudflare/miniflare/miniflare.ts

@@ -7,24 +7,27 @@ import {
 } from "miniflare";
 import path from "node:path";
 import { findOpenPort } from "../../util/find-open-port.ts";
+import { HTTPServer } from "../../util/http-server.ts";
 import { logger } from "../../util/logger.ts";
 import {
   promiseWithResolvers,
   type PromiseWithResolvers,
 } from "../../util/promise-with-resolvers.ts";
-import { HTTPServer } from "./http-server.ts";
 import {
   buildMiniflareWorkerOptions,
   buildRemoteBindings,
   type MiniflareWorkerOptions,
 } from "./miniflare-worker-options.ts";
-import { createMixedModeProxy, type MixedModeProxy } from "./mixed-mode.ts";
+import {
+  createRemoteProxyWorker,
+  type RemoteBindingProxy,
+} from "./remote-binding-proxy.ts";
 
 class MiniflareServer {
   miniflare?: Miniflare;
   workers = new Map<string, WorkerOptions>();
   servers = new Map<string, HTTPServer>();
-  mixedModeProxies = new Map<string, MixedModeProxy>();
+  remoteBindingProxies = new Map<string, RemoteBindingProxy>();
 
   stream = new WritableStream<{
     worker: MiniflareWorkerOptions;
@@ -104,7 +107,7 @@ class MiniflareServer {
     await Promise.all([
       this.miniflare?.dispose(),
       ...Array.from(this.servers.values()).map((server) => server.stop()),
-      ...Array.from(this.mixedModeProxies.values()).map((proxy) =>
+      ...Array.from(this.remoteBindingProxies.values()).map((proxy) =>
         proxy.server.stop(),
       ),
     ]);
@@ -120,7 +123,7 @@ class MiniflareServer {
     if (bindings.length === 0) {
       return undefined;
     }
-    const existing = this.mixedModeProxies.get(worker.name);
+    const existing = this.remoteBindingProxies.get(worker.name);
     if (
       existing?.bindings.every((b) =>
         bindings.find((b2) => b2.name === b.name && b2.type === b.type),
@@ -128,11 +131,11 @@ class MiniflareServer {
     ) {
       return existing.connectionString;
     }
-    const proxy = await createMixedModeProxy({
+    const proxy = await createRemoteProxyWorker({
       name: `mixed-mode-proxy-${crypto.randomUUID()}`,
       bindings,
     });
-    this.mixedModeProxies.set(worker.name, proxy);
+    this.remoteBindingProxies.set(worker.name, proxy);
     return proxy.connectionString;
   }
 

package/src/cloudflare/miniflare/{mixed-mode.ts → remote-binding-proxy.ts}

@@ -1,10 +1,10 @@
 import type { RemoteProxyConnectionString } from "miniflare";
+import { HTTPServer } from "../../util/http-server.ts";
+import { extractCloudflareResult } from "../api-response.ts";
 import { createCloudflareApi, type CloudflareApi } from "../api.ts";
 import type { WorkerBindingSpec } from "../bindings.ts";
-import type { CloudflareApiResponse } from "../types.ts";
+import { getInternalWorkerBundle } from "../bundle/internal-worker-bundle.ts";
 import type { WorkerMetadata } from "../worker-metadata.ts";
-import { getAccountSubdomain, getWorkerTemplate } from "../worker/shared.ts";
-import { HTTPServer } from "./http-server.ts";
 
 type WranglerSessionConfig =
   | {
@@ -22,41 +22,39 @@ interface WorkersPreviewSession {
   token: string;
 }
 
-export async function createMixedModeProxy(input: {
+export async function createRemoteProxyWorker(input: {
   name: string;
   bindings: WorkerBindingSpec[];
 }) {
   const api = await createCloudflareApi();
-  const script = await getWorkerTemplate("mixed-mode-proxy-worker");
+  const script = await getInternalWorkerBundle("remote-binding-proxy");
   const [token, subdomain] = await Promise.all([
     createWorkersPreviewToken(api, {
       name: input.name,
       metadata: {
-        main_module: script.name,
+        main_module: script.file.name,
         compatibility_date: "2025-06-16",
         bindings: input.bindings,
         observability: {
           enabled: false,
         },
       },
-      files: [script],
+      files: [script.file],
       session: {
         workers_dev: true,
         minimal_mode: true,
       },
     }),
-    getAccountSubdomain(api),
+    import("../worker-subdomain.ts").then((m) => m.getAccountSubdomain(api)),
   ]);
-  return new MixedModeProxy(
+  return new RemoteBindingProxy(
     `https://${input.name}.${subdomain}.workers.dev`,
     token,
     input.bindings,
   );
 }
 
-const DEBUG: boolean = false;
-
-export class MixedModeProxy {
+export class RemoteBindingProxy {
   server: HTTPServer;
 
   constructor(
@@ -100,27 +98,6 @@ export class MixedModeProxy {
     responseHeaders.delete("transfer-encoding");
     responseHeaders.delete("content-encoding");
 
-    if (DEBUG) {
-      const clone = res.clone();
-      console.log({
-        request: {
-          url: url.toString(),
-          method: req.method,
-          headers,
-          body: req.body,
-        },
-        response: {
-          status: res.status,
-          headers: res.headers,
-          body: await res.text(),
-        },
-      });
-      return new Response(clone.body, {
-        status: clone.status,
-        headers: responseHeaders,
-      });
-    }
-
     return new Response(res.body, {
       status: res.status,
       headers: responseHeaders,
@@ -144,8 +121,9 @@ async function createWorkersPreviewToken(
     formData.append(file.name, file);
   }
   formData.append("wrangler-session-config", JSON.stringify(input.session));
-  const res = await api
-    .post(
+  const res = await extractCloudflareResult<{ preview_token: string }>(
+    "create workers preview token",
+    api.post(
       `/accounts/${api.accountId}/workers/scripts/${input.name}/edge-preview`,
       formData,
       {
@@ -153,13 +131,8 @@ async function createWorkersPreviewToken(
           "cf-preview-upload-config-token": session.token,
         },
       },
-    )
-    .then((res) =>
-      parseCloudflareResponse<{ preview_token: string }>(
-        res,
-        "Failed to create workers preview token",
-      ),
-    );
+    ),
+  );
   // Fire and forget prewarm call
   // (see https://github.com/cloudflare/workers-sdk/blob/6c6afbd6072b96e78e67d3a863ed849c6aa49472/packages/wrangler/src/dev/create-worker-preview.ts#L338)
   void prewarm(session.prewarm, res.preview_token);
@@ -178,42 +151,19 @@ async function prewarm(url: string, previewToken: string) {
 }
 
 async function createWorkersPreviewSession(api: CloudflareApi) {
-  const { exchange_url } = await api
-    .get(`/accounts/${api.accountId}/workers/subdomain/edge-preview`)
-    .then((res) =>
-      parseCloudflareResponse<{
-        exchange_url: string;
-        token: string;
-      }>(res, "Failed to create workers preview session"),
-    );
-  return await fetch(exchange_url).then((res) =>
-    parseResponse<WorkersPreviewSession>(
-      res,
-      "Failed to create workers preview session",
-    ),
+  const { exchange_url } = await extractCloudflareResult<{
+    exchange_url: string;
+    token: string;
+  }>(
+    "create workers preview session",
+    api.get(`/accounts/${api.accountId}/workers/subdomain/edge-preview`),
   );
-}
-
-async function parseResponse<T>(res: Response, message: string): Promise<T> {
+  const res = await fetch(exchange_url);
   if (!res.ok) {
-    throw new Error(`${message} (${res.status} ${res.statusText})`);
-  }
-  const json: T = await res.json();
-  return json;
-}
-
-async function parseCloudflareResponse<T>(
-  res: Response,
-  message: string,
-): Promise<T> {
-  const json: CloudflareApiResponse<T> = await res.json();
-  if (!json.success) {
     throw new Error(
-      `${message} (${res.status} ${res.statusText} - ${json.errors.map((e) => `${e.code}: ${e.message}`).join(", ")})`,
+      `Failed to create workers preview session: ${res.status} ${res.statusText}`,
     );
   }
-  if (!json.result) {
-    throw new Error(`${message} (${res.status} ${res.statusText})`);
-  }
-  return json.result;
+  const json: WorkersPreviewSession = await res.json();
+  return json;
 }