alchemy 0.64.0 → 0.65.1

package/src/cloudflare/next.ts

@@ -0,0 +1,123 @@
+import * as fs from "node:fs/promises";
+import path from "node:path";
+import pc from "picocolors";
+import { getPackageManagerRunner } from "../util/detect-package-manager.ts";
+import { exists } from "../util/exists.ts";
+import ignore from "../util/ignore-matcher.ts";
+import { logger } from "../util/logger.ts";
+import type { Assets } from "./assets.ts";
+import type { Bindings } from "./bindings.ts";
+import { Website, type WebsiteProps } from "./website.ts";
+import type { Worker } from "./worker.ts";
+
+export interface NextjsProps<B extends Bindings> extends WebsiteProps<B> {}
+
+export type Nextjs<B extends Bindings> = B extends { ASSETS: any }
+  ? never
+  : Worker<B & { ASSETS: Assets }>;
+
+export async function Nextjs<const B extends Bindings>(
+  id: string,
+  props: NextjsProps<B> = {},
+): Promise<Nextjs<B>> {
+  const runner = await getPackageManagerRunner();
+  const isIgnored = await isFileIgnored("wrangler.jsonc", props.cwd);
+  if (!isIgnored) {
+    logger.warn(
+      [
+        pc.bold(
+          `The ${pc.cyan("wrangler.jsonc")} file for Next.js ${pc.cyan(`"${id}"`)} is not ignored.`,
+        ),
+        "This may cause unexpected behavior. Please add the file to your .gitignore.",
+      ].join(" "),
+    );
+  }
+  return await Website(id, {
+    ...props,
+    entrypoint: props.entrypoint ?? ".open-next/worker.js",
+    wrangler: {
+      path: "wrangler.jsonc",
+      secrets: isIgnored,
+      ...(props.wrangler ?? {}),
+    },
+    build: normalizeCommand(props.build, {
+      command: `${runner} opennextjs-cloudflare build`,
+      env: {
+        NEXTJS_ENV: "production",
+      },
+    }),
+    dev: normalizeCommand(props.dev, {
+      command: `${runner} next dev`,
+      env: {
+        NEXTJS_ENV: "development",
+      },
+    }),
+
+    // OpenNext generates the files, but relies on us to bundle them.
+    noBundle: props.noBundle ?? false,
+
+    spa: false,
+    compatibilityFlags: [
+      "nodejs_compat",
+      "global_fetch_strictly_public",
+      ...(props.compatibilityFlags ?? []),
+    ],
+    assets: props.assets ?? ".open-next/assets",
+  });
+}
+
+/**
+ * Check if a file is ignored by .gitignore.
+ *
+ * @param filename - The name of the file to check.
+ * @param cwd - The current working directory.
+ * @returns True if the file is ignored, false otherwise.
+ */
+const isFileIgnored = async (filename: string, cwd?: string) => {
+  const matcher = ignore();
+
+  // Read .gitignore from current directory and walk up the directory tree
+  let currentDir = path.resolve(cwd ?? process.cwd());
+  const gitignorePatterns: string[] = [];
+
+  while (currentDir !== path.dirname(currentDir)) {
+    const gitignorePath = path.join(currentDir, ".gitignore");
+    try {
+      const gitignoreContent = await fs.readFile(gitignorePath, "utf8");
+      // unshift to prioritize local .gitignore
+      gitignorePatterns.unshift(
+        ...gitignoreContent
+          .split("\n")
+          .filter((line) => line.trim() && !line.startsWith("#")),
+      );
+    } catch {
+      // .gitignore doesn't exist in this directory, continue up
+    }
+    if (await exists(path.join(currentDir, ".git"))) {
+      break;
+    }
+    currentDir = path.dirname(currentDir);
+  }
+
+  matcher.add(gitignorePatterns);
+
+  return matcher.ignores(filename);
+};
+
+const normalizeCommand = (
+  input: WebsiteProps<any>["build"],
+  defaults: {
+    command: string;
+    env: Record<string, string>;
+  },
+): WebsiteProps<any>["build"] => {
+  return {
+    command:
+      typeof input === "string" ? input : (input?.command ?? defaults.command),
+    env: {
+      ...defaults.env,
+      ...(typeof input === "object" ? (input?.env ?? {}) : {}),
+    },
+    memoize: typeof input === "object" ? input?.memoize : undefined,
+  };
+};

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