alchemy 0.45.6 → 0.46.0

package/src/cloudflare/auth.ts

@@ -1,8 +1,5 @@
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
 import type { Secret } from "../secret.ts";
-import { createXdgAppPaths } from "../util/xdg-paths.ts";
+import { getRefreshedWranglerConfig } from "./auth-wrangler.ts";
 /**
  * Authentication options for Cloudflare API
  */
@@ -72,162 +69,17 @@ export async function getCloudflareAuthHeaders(
     };
   }
   // Wrangler OAuth Token
-  const authConfig = await getRefreshedAuthConfig();
-  if (authConfig.oauth_token) {
+  const wranglerConfig = await getRefreshedWranglerConfig();
+  if (wranglerConfig.isOk() && wranglerConfig.value) {
     return {
-      Authorization: `Bearer ${authConfig.oauth_token}`,
+      Authorization: `Bearer ${wranglerConfig.value.oauth_token}`,
     };
-  }
-  throw new Error(
-    "Cloudflare authentication required. Did you forget to login with `wrangler login` or set CLOUDFLARE_API_TOKEN, CLOUDFLARE_API_KEY?",
-  );
-}
-
-async function refreshAuthToken(
-  options: WranglerConfig,
-): Promise<WranglerConfig> {
-  const response = await fetch("https://dash.cloudflare.com/oauth2/token", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/x-www-form-urlencoded",
-    },
-    body: new URLSearchParams({
-      grant_type: "refresh_token",
-      refresh_token: options.refresh_token!,
-      client_id: "54d11594-84e4-41aa-b438-e81b8fa78ee7",
-    }).toString(),
-  });
-
-  if (!response.ok) {
+  } else if (wranglerConfig.isErr()) {
     throw new Error(
-      `Failed to refresh auth token: ${response.status} ${response.statusText} ${await response.text()}`,
+      `Cloudflare authentication failed: ${wranglerConfig.error.message}`,
     );
   }
-
-  const data: any = await response.json();
-  if (!data.access_token) {
-    throw new Error("Failed to refresh auth token - no access token returned");
-  }
-
-  options.oauth_token = data.access_token;
-  options.refresh_token = data.refresh_token;
-  options.expiration_time = new Date(
-    Date.now() + data.expires_in * 1000,
-  ).toISOString();
-  options.scopes = data.scope?.split(" ") || [];
-
-  return options;
-}
-
-interface WranglerConfig {
-  path: string;
-  oauth_token?: string;
-  refresh_token?: string;
-  expiration_time?: string;
-  scopes?: string[];
-  /** exists is `false` if the config file doesn't exist, like in CI */
-  exists?: boolean;
-  /** @deprecated - this field was only provided by the deprecated v1 `wrangler config` command. */
-  api_token?: string;
-}
-
-async function getRefreshedAuthConfig(): Promise<WranglerConfig> {
-  let authConfig = await readWranglerConfig();
-  if (authConfig.expiration_time) {
-    const expiry = new Date(authConfig.expiration_time);
-    // if expiring in 10s
-    if (expiry.getTime() < Date.now() + 10 * 1000) {
-      authConfig = await refreshAuthToken(authConfig);
-      authConfigCache[authConfig.path] = authConfig;
-      await writeWranglerConfig(authConfig);
-    }
-  }
-  return authConfig;
-}
-
-async function writeWranglerConfig(config: WranglerConfig) {
-  if (config.exists === false) return;
-
-  const TOML = await import("@iarna/toml");
-  const configPath = await findWranglerConfig();
-  config = {
-    ...config,
-  };
-  // @ts-ignore - i put this here
-  delete config.path;
-  const toml = TOML.stringify(config as any);
-  await fs.writeFile(configPath, toml);
-}
-
-// cache the file once per process
-const authConfigCache: Record<string, WranglerConfig> = {};
-
-async function readWranglerConfig(): Promise<WranglerConfig> {
-  const configPath = await findWranglerConfig();
-  try {
-    const config = (authConfigCache[configPath] ??= await parseTOML(
-      await fs.readFile(configPath, "utf-8"),
-    ));
-    config.path = configPath;
-
-    return config;
-  } catch (e: any) {
-    if (e.code === "ENOENT") {
-      // The config doesn't exist
-      return {
-        path: configPath,
-        exists: false,
-      };
-    }
-
-    throw e;
-  }
-}
-
-let wranglerConfigPath: string | undefined;
-
-async function findWranglerConfig(): Promise<string> {
-  if (wranglerConfigPath) {
-    return wranglerConfigPath;
-  }
-  const environment = process.env.WRANGLER_API_ENVIRONMENT ?? "production";
-  const filePath = path.join(
-    "config",
-    `${environment === "production" ? "default.toml" : `${environment}.toml`}`,
-  );
-
-  const xdgAppPaths = createXdgAppPaths(".wrangler");
-  //TODO: We should implement a custom path --global-config and/or the WRANGLER_HOME type environment variable
-  const configDir = xdgAppPaths.config(); // New XDG compliant config path
-  const legacyConfigDir = path.join(os.homedir(), ".wrangler"); // Legacy config in user's home directory
-
-  // Check for the .wrangler directory in root if it is not there then use the XDG compliant path.
-  wranglerConfigPath = path.join(
-    (await isDirectory(legacyConfigDir)) ? legacyConfigDir : configDir,
-    filePath,
+  throw new Error(
+    "Cloudflare authentication required. Did you forget to login with `wrangler login` or set CLOUDFLARE_API_TOKEN, CLOUDFLARE_API_KEY?",
   );
-  return wranglerConfigPath;
-}
-
-async function parseTOML(input: string): Promise<any> {
-  const TOML = await import("@iarna/toml");
-  try {
-    // Normalize CRLF to LF to avoid hitting https://github.com/iarna/iarna-toml/issues/33.
-    const normalizedInput = input.replace(/\r\n/g, "\n");
-    return TOML.parse(normalizedInput);
-  } catch (err: any) {
-    const { name } = err;
-    if (name !== "TomlError") {
-      throw err;
-    }
-    throw new Error("TOML parse error");
-  }
-}
-
-async function isDirectory(dir: string) {
-  try {
-    return (await fs.stat(dir)).isDirectory();
-  } catch (_err) {
-    return false;
-  }
 }

package/src/cloudflare/browser-rendering.ts

@@ -1,3 +1,17 @@
-export class BrowserRendering {
-  public readonly type = "browser";
+export type BrowserRendering = {
+  type: "browser";
+};
+
+/**
+ * Creates a browser rendering binding for running browser tasks in Workers.
+ *
+ * @example
+ * ```ts
+ * const browser = BrowserRendering();
+ * ```
+ */
+export function BrowserRendering(): BrowserRendering {
+  return {
+    type: "browser",
+  };
 }

package/src/cloudflare/bundle/fs.ts

@@ -45,6 +45,11 @@ export class FSBundleProvider implements WorkerBundleProvider {
         }
       }),
     );
+    if (fileNames.size === 0) {
+      throw new Error(
+        `No files found matching ${this.globs.join(", ")} in ${this.root}`,
+      );
+    }
     const { files, hash } = await parseFiles(
       this.root,
       Array.from(fileNames),

package/src/cloudflare/bundle/internal-worker-bundle.ts

@@ -0,0 +1,21 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { memoize } from "../../util/memoize.ts";
+
+export type InternalWorker =
+  | "cloudflare-state-store"
+  | "dofs-state-store"
+  | "remote-binding-proxy";
+
+export const getInternalWorkerBundle = memoize(async (name: InternalWorker) => {
+  const content = await fs.readFile(
+    path.join(import.meta.dirname, "..", "..", "..", "workers", `${name}.js`),
+  );
+  return {
+    file: new File([content], `${name}.js`, {
+      type: "application/javascript+module",
+    }),
+    tag: `${name}:${crypto.createHash("sha256").update(content).digest("hex")}`,
+  };
+});

package/src/cloudflare/compatibility-presets.ts

@@ -0,0 +1,34 @@
+/**
+ * Compatibility presets for Cloudflare Workers
+ *
+ * These presets provide common sets of compatibility flags to avoid
+ * users having to remember which flags they need for common use cases.
+ */
+
+/**
+ * Mapping of compatibility presets to their respective compatibility flags
+ */
+export const COMPATIBILITY_PRESETS = {
+  /**
+   * Node.js compatibility preset
+   * Enables Node.js APIs and runtime compatibility
+   */
+  node: ["nodejs_compat"],
+} as const;
+
+export type CompatibilityPreset = keyof typeof COMPATIBILITY_PRESETS;
+
+/**
+ * Union preset compatibility flags with user-provided flags
+ */
+export function unionCompatibilityFlags(
+  preset: CompatibilityPreset | undefined,
+  userFlags: string[] = [],
+): string[] {
+  if (!preset) {
+    return userFlags;
+  }
+
+  const presetFlags = COMPATIBILITY_PRESETS[preset];
+  return Array.from(new Set([...presetFlags, ...userFlags]));
+}

package/src/cloudflare/container.ts

@@ -545,7 +545,7 @@ export const ContainerApplication = Resource(
       let application: ContainerApplicationData;
 
       try {
-        application = await createContainerApplication(api, {
+        application = await createContainerApplication(api, props.adopt, {
           name: props.name,
           scheduling_policy: props.schedulingPolicy ?? "default",
           instances: props.instances ?? 1,
@@ -734,6 +734,23 @@ export interface ContainerApplicationData {
   [key: string]: any;
 }
 
+export async function getContainerApplication(
+  api: CloudflareApi,
+  applicationId: string,
+) {
+  const response = await api.get(
+    `/accounts/${api.accountId}/containers/applications/${applicationId}`,
+  );
+
+  const result = (await response.json()) as {
+    result: ContainerApplicationData;
+    errors: { message: string }[];
+  };
+  if (response.ok) {
+    return result.result;
+  }
+}
+
 export async function listContainerApplications(
   api: CloudflareApi,
 ): Promise<ContainerApplicationData[]> {
@@ -770,11 +787,15 @@ export interface CreateContainerApplicationBody {
   instances?: number;
   scheduling_policy?: string;
   constraints?: { tier: number };
+  affinities?: {
+    colocation?: "datacenter";
+  };
   [key: string]: any;
 }
 
 export async function createContainerApplication(
   api: CloudflareApi,
+  adopt: boolean | undefined,
   body: CreateContainerApplicationBody,
 ) {
   const response = await api.post(
@@ -783,17 +804,63 @@ export async function createContainerApplication(
   );
   const result = (await response.json()) as {
     result: ContainerApplicationData;
-    errors: { message: string }[];
+    errors: { message: string; code: number }[];
   };
   if (response.ok) {
     return result.result;
   }
 
+  const error = result.errors.find((e) => e.code === 1000);
+  if (error) {
+    // WEIRD: json-encoded error message - might change when they release an official API
+    const errorMessage = JSON.parse(error.message) as {
+      error: "DURABLE_OBJECT_ALREADY_HAS_APPLICATION" | (string & {});
+      details: {
+        name: string;
+        id: string;
+      };
+    };
+
+    if (errorMessage.error === "DURABLE_OBJECT_ALREADY_HAS_APPLICATION") {
+      if (!adopt) {
+        throw new Error(
+          `Durable Object namespace ${body.durable_objects?.namespace_id} already has an application with id ${errorMessage.details.id}. Use adopt: true to adopt it.`,
+        );
+      }
+      const application = await getContainerApplication(
+        api,
+        errorMessage.details.id,
+      );
+      if (application) {
+        const currentId = application.durable_objects.namespace_id;
+        const desiredId = body.durable_objects?.namespace_id;
+        if (currentId === desiredId) {
+          await updateContainerApplication(api, application.id, {
+            configuration: body.configuration,
+            instances: body.instances,
+            constraints: body.constraints,
+            scheduling_policy: body.scheduling_policy,
+            max_instances: body.max_instances,
+            affinities: body.affinities,
+            // TODO(sam): API does not accepet this as input, we may need to repace
+            // durable_objects: body.durable_objects,
+          });
+          // it's the same application, so we can just adpt it
+          return application;
+        } else {
+          // TODO(sam): not sure what to do in this case
+          throw new Error(
+            "Cannot adopt an existing Container Application that is bound to a different Durable Object",
+          );
+        }
+      }
+    }
+  }
+
   throw Error(
     `Failed to create container application: ${result.errors?.map((e: { message: string }) => e.message).join(", ") ?? "Unknown error"}`,
   );
 }
-
 type Region =
   | "AFR"
   | "APAC"

package/src/cloudflare/dispatch-namespace.ts

@@ -279,3 +279,31 @@ export async function deleteDispatchNamespace(
     );
   }
 }
+
+export async function listWorkersInNamespace(
+  api: CloudflareApi,
+  namespace: string,
+): Promise<Array<{ id: string; created_on: string; modified_on: string }>> {
+  const response = await api.get(
+    `/accounts/${api.accountId}/workers/dispatch/namespaces/${namespace}/scripts`,
+  );
+
+  if (!response.ok) {
+    await handleApiError(
+      response,
+      "list workers in",
+      "dispatch_namespace",
+      namespace,
+    );
+  }
+
+  const data = (await response.json()) as {
+    result: Array<{
+      id: string;
+      created_on: string;
+      modified_on: string;
+    }>;
+  };
+
+  return data.result || [];
+}

package/src/cloudflare/durable-object-namespace.ts

@@ -3,7 +3,7 @@ import type { Binding } from "./bindings.ts";
 /**
  * Properties for creating a Durable Object Namespace
  */
-export interface DurableObjectNamespaceInput {
+export interface DurableObjectNamespaceProps {
   className: string;
   scriptName?: string | undefined;
   environment?: string | undefined;
@@ -11,6 +11,18 @@ export interface DurableObjectNamespaceInput {
   namespaceId?: string | undefined;
 }
 
+export type DurableObjectNamespace<T = any> = {
+  type: "durable_object_namespace";
+  id: string;
+  className: string;
+  scriptName?: string;
+  environment?: string;
+  sqlite?: boolean;
+  namespaceId?: string;
+  // @ts-ignore - phantom type
+  __service__: T;
+};
+
 export function isDurableObjectNamespace(
   binding: Binding,
 ): binding is DurableObjectNamespace {
@@ -20,48 +32,47 @@ export function isDurableObjectNamespace(
 }
 
 /**
+ * Creates a Durable Object namespace binding.
+ *
  * @example
+ * ```ts
  * // Create a basic Durable Object namespace for stateful chat rooms
- * const rooms = new DurableObjectNamespace("chat-rooms", {
+ * const rooms = DurableObjectNamespace("chat-rooms", {
  *   className: "ChatRoom"
  * });
+ * ```
  *
  * @example
+ * ```ts
  * // Create a Durable Object with SQLite storage for user data
- * const users = new DurableObjectNamespace("user-store", {
+ * const users = DurableObjectNamespace("user-store", {
  *   className: "User",
  *   sqlite: true
  * });
+ * ```
  *
  * @example
+ * ```ts
  * // Create a Durable Object in production for game state management
- * const game = new DurableObjectNamespace("game-state", {
+ * const game = DurableObjectNamespace("game-state", {
  *   className: "GameState",
  *   scriptName: "game-worker",
  *   environment: "production"
  * });
+ * ```
  */
-export class DurableObjectNamespace<T = any>
-  implements DurableObjectNamespaceInput
-{
-  public readonly type = "durable_object_namespace" as const;
-  // alias for bindingName to be consistent with other bindings
-  public readonly className: string;
-  public readonly scriptName?: string | undefined;
-  public readonly environment?: string | undefined;
-  public readonly sqlite?: boolean | undefined;
-  public readonly namespaceId?: string | undefined;
-
-  // @ts-ignore - phantom type
-  protected readonly __service__: T;
-
-  constructor(
-    public readonly id: string,
-    input: DurableObjectNamespaceInput,
-  ) {
-    this.className = input.className;
-    this.scriptName = input.scriptName;
-    this.environment = input.environment;
-    this.sqlite = input.sqlite;
-  }
+export function DurableObjectNamespace<T = any>(
+  id: string,
+  props: DurableObjectNamespaceProps,
+): DurableObjectNamespace<T> {
+  return {
+    type: "durable_object_namespace",
+    id,
+    className: props.className,
+    scriptName: props.scriptName,
+    environment: props.environment,
+    sqlite: props.sqlite,
+    namespaceId: props.namespaceId,
+    __service__: undefined!,
+  };
 }

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;
-  }
 }