alchemy 0.64.0 → 0.65.0

package/src/cloudflare/worker-assets.ts

@@ -2,10 +2,10 @@ import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { AsyncQueue } from "../util/async-queue.ts";
-import { getContentType } from "../util/content-type.ts";
-import { CloudflareApiError } from "./api-error.ts";
+import { withExponentialBackoff } from "../util/retry.ts";
+import { extractCloudflareResult } from "./api-response.ts";
 import type { CloudflareApi } from "./api.ts";
-import type { Assets } from "./assets.ts";
+import type { AssetFile, Assets } from "./assets.ts";
 import type { AssetsConfig, WorkerProps } from "./worker.ts";
 
 export interface AssetUploadResult {
@@ -21,32 +21,6 @@ interface FileMetadata {
   size: number;
 }
 
-/**
- * Response from the assets upload session API
- */
-interface UploadSessionResponse {
-  result: {
-    jwt: string;
-    buckets: string[][];
-  };
-  success: boolean;
-  errors: any[];
-  messages: any[];
-}
-
-/**
- * Response from the file upload API
- */
-interface UploadResponse {
-  result: {
-    jwt: string;
-    buckets?: string[][];
-  };
-  success: boolean;
-  errors: any[];
-  messages: any[];
-}
-
 /**
  * Uploads assets to Cloudflare and returns a completion token
  *
@@ -73,64 +47,41 @@ export async function uploadAssets(
   // Process the assets configuration once at the beginning
   const processedConfig = createAssetConfig(assetConfig);
 
-  const { manifest, filePathsByHash } = await prepareAssetManifest(assets);
+  const { manifest, filesByHash } = await prepareAssetManifest(assets);
 
   // Start the upload session
-  const uploadSessionResponse = await api.post(
-    namespace
-      ? `/accounts/${api.accountId}/workers/dispatch/namespaces/${namespace}/scripts/${workerName}/assets-upload-session`
-      : `/accounts/${api.accountId}/workers/scripts/${workerName}/assets-upload-session`,
-    JSON.stringify({ manifest }),
-    {
-      headers: { "Content-Type": "application/json" },
-    },
+  const uploadSession = await extractCloudflareResult<{
+    jwt: string;
+    buckets: string[][];
+  }>(
+    `create assets upload session for worker "${workerName}"`,
+    api.post(
+      namespace
+        ? `/accounts/${api.accountId}/workers/dispatch/namespaces/${namespace}/scripts/${workerName}/assets-upload-session`
+        : `/accounts/${api.accountId}/workers/scripts/${workerName}/assets-upload-session`,
+      { manifest },
+    ),
   );
-
-  if (!uploadSessionResponse.ok) {
-    throw new Error(
-      `Failed to start assets upload session: ${uploadSessionResponse.status} ${uploadSessionResponse.statusText} - ${await uploadSessionResponse.text()}`,
-    );
-  }
-
-  const sessionData =
-    (await uploadSessionResponse.json()) as UploadSessionResponse;
-
-  if (!sessionData?.success) {
-    if (sessionData?.errors) {
-      throw new CloudflareApiError(
-        `Failed to start assets upload session:\n${sessionData.errors
-          .map((error) => `- ${error.code}: ${error.message}`)
-          .join("\n")}`,
-        uploadSessionResponse,
-      );
-    }
-    throw new CloudflareApiError(
-      `Failed to start assets upload session: ${uploadSessionResponse.statusText}`,
-      uploadSessionResponse,
-    );
-  }
-
   // If there are no buckets, assets are already uploaded or empty
-  if (!sessionData.result.buckets || sessionData.result.buckets.length === 0) {
+  if (!uploadSession.buckets || uploadSession.buckets.length === 0) {
     return {
-      completionToken: sessionData.result.jwt,
+      completionToken: uploadSession.jwt,
       assetConfig: processedConfig,
     };
   }
 
   // Upload the files in batches as specified by the API
-  let completionToken = sessionData.result.jwt;
-  const buckets = sessionData.result.buckets;
+  let completionToken = uploadSession.jwt;
+  const buckets = uploadSession.buckets;
 
   const queue = new AsyncQueue(3);
   await Promise.all(
     buckets.map((bucket) =>
       queue.add(async () => {
-        const jwt = await uploadBucket(
-          api,
-          sessionData.result.jwt,
-          bucket,
-          filePathsByHash,
+        const jwt = await withExponentialBackoff(
+          async () =>
+            await uploadBucket(api, uploadSession.jwt, bucket, filesByHash),
+          () => true,
         );
         if (jwt) {
           completionToken = jwt;
@@ -183,68 +134,55 @@ export function createAssetConfig(config?: AssetsConfig): AssetsConfig {
  * Prepares the asset manifest for the assets upload session
  *
  * @param assets Assets resource containing files to upload
- * @returns Asset manifest and file paths by hash
+ * @returns Asset manifest and files by hash
  */
 export async function prepareAssetManifest(assets: Assets) {
   const manifest: Record<string, FileMetadata> = {};
-  const filePathsByHash = new Map<string, string>();
+  const filesByHash = new Map<string, AssetFile>();
   await Promise.all(
     assets.files.map(async (file) => {
       const { hash, size } = await calculateFileMetadata(file.filePath);
       const key = file.path.startsWith("/") ? file.path : `/${file.path}`;
       manifest[key] = { hash, size };
-      filePathsByHash.set(hash, file.filePath);
+      filesByHash.set(hash, file);
     }),
   );
-  return { manifest, filePathsByHash };
+  return { manifest, filesByHash };
 }
 
 async function uploadBucket(
   api: CloudflareApi,
   jwt: string,
   bucket: string[],
-  files: Map<string, string>,
+  filesByHash: Map<string, AssetFile>,
 ) {
   const formData = new FormData();
   await Promise.all(
     bucket.map(async (fileHash) => {
-      const filePath = files.get(fileHash);
-      if (!filePath) {
+      const file = filesByHash.get(fileHash);
+      if (!file) {
         throw new Error(`Could not find file with hash ${fileHash}`);
       }
-      const fileContent = await fs.readFile(filePath);
+      const fileContent = await fs.readFile(file.filePath);
       const blob = new Blob([fileContent.toString("base64")], {
-        type: getContentType(filePath) ?? "application/null",
+        type: file.contentType,
       });
       formData.append(fileHash, blob, fileHash);
     }),
   );
-  const uploadResponse = await api.post(
-    `/accounts/${api.accountId}/workers/assets/upload?base64=true`,
-    formData,
-    {
-      headers: {
-        Authorization: `Bearer ${jwt}`,
-        "Content-Type": "multipart/form-data",
+  const uploadResult = await extractCloudflareResult<{ jwt?: string }>(
+    "upload asset files",
+    api.post(
+      `/accounts/${api.accountId}/workers/assets/upload?base64=true`,
+      formData,
+      {
+        headers: {
+          Authorization: `Bearer ${jwt}`,
+        },
       },
-    },
+    ),
   );
-
-  if (!uploadResponse.ok) {
-    throw new Error(
-      `Failed to upload asset files: ${uploadResponse.status} ${uploadResponse.statusText}`,
-    );
-  }
-
-  const uploadData = (await uploadResponse.json()) as UploadResponse;
-  if (!uploadData.success) {
-    const error = uploadData.errors[0];
-    const message = error.message;
-    const code = error.code;
-    throw new Error(`Failed to upload asset files: ${message} (Code: ${code})`);
-  }
-
-  return uploadData.result.jwt;
+  return uploadResult.jwt;
 }
 
 /**

package/src/cloudflare/wrangler.json.ts

@@ -353,8 +353,8 @@ export interface WranglerJsonSpec {
    * Queue bindings
    */
   queues?: {
-    producers: { queue: string; binding: string }[];
-    consumers: {
+    producers?: { queue: string; binding: string }[];
+    consumers?: {
       queue: string;
       max_batch_size?: number;
       max_concurrency?: number;
@@ -845,7 +845,10 @@ function processBindings(
   }
 
   if (queues.consumers.length > 0) {
-    spec.queues = queues;
+    (spec.queues ??= {}).consumers = queues.consumers;
+  }
+  if (queues.producers.length > 0) {
+    (spec.queues ??= {}).producers = queues.producers;
   }
 
   if (vectorizeIndexes.length > 0) {

package/src/planetscale/branch.ts

@@ -4,7 +4,8 @@ import type { PlanetScaleProps } from "./api/client.gen.ts";
 import { PlanetScaleClient } from "./api/client.gen.ts";
 import {
   ensureProductionBranchClusterSize,
-  waitForDatabaseReady,
+  sanitizeClusterSize,
+  waitForBranchReady,
   type PlanetScaleClusterSize,
 } from "./utils.ts";
 
@@ -159,6 +160,11 @@ export const Branch = Resource(
 
     const branchName =
       props.name ?? this.output?.name ?? this.scope.createPhysicalName(id);
+    const parentBranchName = !props.parentBranch
+      ? "main"
+      : typeof props.parentBranch === "string"
+        ? props.parentBranch
+        : props.parentBranch.name;
 
     if (this.phase === "update" && this.output.name !== branchName) {
       // TODO(sam): maybe we don't need to replace? just branch again? or rename?
@@ -188,14 +194,8 @@ export const Branch = Resource(
       return this.destroy();
     }
 
-    const parentBranchName = !props.parentBranch
-      ? "main"
-      : typeof props.parentBranch === "string"
-        ? props.parentBranch
-        : props.parentBranch.name;
-
     if (typeof props.parentBranch !== "string" && props.parentBranch) {
-      await waitForDatabaseReady(
+      await waitForBranchReady(
         api,
         props.organizationId,
         props.databaseName,
@@ -262,17 +262,28 @@ export const Branch = Resource(
         });
       }
 
-      if (props.clusterSize && data.cluster_name !== props.clusterSize) {
-        await api.organizations.databases.branches.cluster.patch({
-          path: {
-            organization: props.organizationId,
-            database: props.databaseName,
-            name: branchName,
-          },
-          body: {
-            cluster_size: props.clusterSize,
-          },
-        });
+      const clusterSize = props.clusterSize
+        ? sanitizeClusterSize({
+            size: props.clusterSize,
+            kind: data.kind,
+            arch: data.cluster_architecture === "aarch64" ? "arm" : "x86",
+            region: data.region.slug,
+          })
+        : undefined;
+      if (clusterSize && data.cluster_name !== clusterSize) {
+        if (!props.isProduction) {
+          throw new Error(
+            `Cannot change cluster size of non-production branch ${branchName}`,
+          );
+        }
+        await ensureProductionBranchClusterSize(
+          api,
+          props.organizationId,
+          props.databaseName,
+          branchName,
+          data.kind,
+          clusterSize,
+        );
       }
 
       return this({
@@ -284,7 +295,21 @@ export const Branch = Resource(
         htmlUrl: data.html_url,
       });
     }
-    await waitForDatabaseReady(api, props.organizationId, props.databaseName);
+    let clusterSize: string | undefined;
+    const parent = await waitForBranchReady(
+      api,
+      props.organizationId,
+      props.databaseName,
+      parentBranchName,
+    );
+    if (props.clusterSize) {
+      clusterSize = sanitizeClusterSize({
+        size: props.clusterSize,
+        kind: parent.kind,
+        arch: parent.cluster_architecture === "aarch64" ? "arm" : "x86",
+        region: parent.region.slug,
+      });
+    }
 
     // Branch doesn't exist, create it
     const data = await api.organizations.databases.branches.post({
@@ -297,14 +322,15 @@ export const Branch = Resource(
         parent_branch: parentBranchName,
         backup_id: props.backupId,
         seed_data: props.seedData,
-        cluster_size: props.clusterSize,
+        // This is ignored unless props.backupId is provided
+        cluster_size: clusterSize,
       },
     });
 
     // Handle safe migrations if specified
     if (props.safeMigrations !== undefined) {
-      // We can't change the migrations mode if the database is not ready
-      await waitForDatabaseReady(
+      // We can't change the migrations mode if the branch is not ready
+      await waitForBranchReady(
         api,
         props.organizationId,
         props.databaseName,
@@ -322,15 +348,14 @@ export const Branch = Resource(
     }
 
     // Handle cluster size update if specified
-    if (props.clusterSize) {
-      // Wait for database to be ready before modifying cluster size
+    if (clusterSize) {
       await ensureProductionBranchClusterSize(
         api,
         props.organizationId,
         props.databaseName,
         branchName,
-        props.clusterSize,
-        true,
+        data.kind,
+        clusterSize,
       );
     }
 

package/src/planetscale/database.ts

@@ -5,13 +5,11 @@ import { PlanetScaleClient } from "./api/client.gen.ts";
 import {
   ensureProductionBranchClusterSize,
   type PlanetScaleClusterSize,
+  sanitizeClusterSize,
   waitForDatabaseReady,
 } from "./utils.ts";
 
-/**
- * Properties for creating or updating a PlanetScale Database
- */
-export interface DatabaseProps extends PlanetScaleProps {
+interface BaseDatabaseProps extends PlanetScaleProps {
   /**
    * The name of the database
    *
@@ -88,54 +86,79 @@ export interface DatabaseProps extends PlanetScaleProps {
    * The database cluster size (required)
    */
   clusterSize: PlanetScaleClusterSize;
-}
 
-/**
- * Represents a PlanetScale Database
- */
-export interface Database
-  extends Resource<"planetscale::Database">,
-    DatabaseProps {
   /**
-   * The unique identifier of the database
+   * The engine kind for the database
+   * @default "mysql"
    */
-  id: string;
+  kind?: "mysql" | "postgresql";
 
   /**
-   * The name of the database
+   * The CPU architecture for the database. Only available for PostgreSQL databases.
    */
-  name: string;
+  arch?: "x86" | "arm";
+}
 
-  /**
-   * The current state of the database
-   */
-  state: string;
+/**
+ * Properties for creating or updating a PlanetScale Database
+ */
+export type DatabaseProps = BaseDatabaseProps &
+  (
+    | {
+        kind?: "mysql";
+        arch?: undefined;
+      }
+    | {
+        kind: "postgresql";
+        arch?: "x86" | "arm";
+      }
+  );
 
-  /**
-   * The default branch name
-   */
-  defaultBranch: string;
+/**
+ * Represents a PlanetScale Database
+ */
+export type Database = Resource<"planetscale::Database"> &
+  DatabaseProps & {
+    /**
+     * The unique identifier of the database
+     */
+    id: string;
 
-  /**
-   * The plan type
-   */
-  plan: string;
+    /**
+     * The name of the database
+     */
+    name: string;
 
-  /**
-   * Time at which the database was created
-   */
-  createdAt: string;
+    /**
+     * The current state of the database
+     */
+    state: string;
 
-  /**
-   * Time at which the database was last updated
-   */
-  updatedAt: string;
+    /**
+     * The default branch name
+     */
+    defaultBranch: string;
 
-  /**
-   * HTML URL to access the database
-   */
-  htmlUrl: string;
-}
+    /**
+     * The plan type
+     */
+    plan: string;
+
+    /**
+     * Time at which the database was created
+     */
+    createdAt: string;
+
+    /**
+     * Time at which the database was last updated
+     */
+    updatedAt: string;
+
+    /**
+     * HTML URL to access the database
+     */
+    htmlUrl: string;
+  };
 
 /**
  * Create, manage and delete PlanetScale databases
@@ -182,6 +205,12 @@ export const Database = Resource(
 
     const databaseName =
       props.name ?? this.output?.name ?? this.scope.createPhysicalName(id);
+    const clusterSize = sanitizeClusterSize({
+      size: props.clusterSize,
+      kind: props.kind,
+      arch: props.arch,
+      region: props.region?.slug,
+    });
 
     if (this.phase === "update" && this.output.name !== databaseName) {
       await api.organizations.databases.patch({
@@ -278,8 +307,8 @@ export const Database = Resource(
         props.organizationId,
         databaseName,
         props.defaultBranch || "main",
-        props.clusterSize,
-        updateResponse.ready,
+        updateResponse.kind,
+        clusterSize,
       );
 
       return this({
@@ -307,8 +336,8 @@ export const Database = Resource(
       body: {
         name: databaseName,
         region: props.region?.slug,
-        kind: "mysql",
-        cluster_size: props.clusterSize,
+        kind: props.kind,
+        cluster_size: clusterSize,
       },
     });
 
@@ -362,8 +391,8 @@ export const Database = Resource(
           props.organizationId,
           databaseName,
           props.defaultBranch || "main",
-          props.clusterSize,
-          false,
+          data.kind,
+          clusterSize,
         );
 
         // Update database to use new branch as default

package/src/planetscale/index.ts

@@ -2,4 +2,5 @@ export * from "./api/client.gen.ts";
 export * from "./branch.ts";
 export * from "./database.ts";
 export * from "./password.ts";
+export * from "./role.ts";
 export * from "./utils.ts";

package/src/planetscale/password.ts

@@ -102,7 +102,9 @@ export interface Password
 }
 
 /**
- * Create and manage database passwords for PlanetScale branches. Database passwords provide secure access to your database with specific roles and permissions.
+ * Create and manage database passwords for PlanetScale MySQL branches. Database passwords provide secure access to your database with specific roles and permissions.
+ *
+ * For Postgres, use [Roles](./role.ts) instead.
  *
  * @example
  * ## Basic Reader Password