alchemy 0.81.4 → 0.82.1

package/src/cloudflare/d1-sql-file.ts

@@ -0,0 +1,52 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import path from "pathe";
+
+export interface D1SqlFile {
+  id: string;
+  sql: string;
+  hash: string;
+}
+
+/**
+ * Lists SQL files from the directory, sorted by filename.
+ * @param directory Directory containing .sql files
+ */
+export async function listSqlFiles(directory: string): Promise<D1SqlFile[]> {
+  const files = await Array.fromAsync(
+    fs.glob("**/*.sql", {
+      cwd: directory,
+    }),
+  );
+
+  const sortedFiles = files.sort((a: string, b: string) => {
+    const aNum = getPrefix(a);
+    const bNum = getPrefix(b);
+
+    if (aNum !== null && bNum !== null) return aNum - bNum;
+    if (aNum !== null) return -1;
+    if (bNum !== null) return 1;
+
+    return a.localeCompare(b);
+  });
+
+  return Promise.all(sortedFiles.map((id) => readSqlFile(directory, id)));
+}
+
+export async function readSqlFile(
+  directory: string,
+  name: string,
+): Promise<D1SqlFile> {
+  const sql = await fs.readFile(path.resolve(directory, name), "utf-8");
+  const hash = crypto.createHash("sha256").update(sql).digest("hex");
+  const file: D1SqlFile = { id: name, sql, hash };
+  // Make the sql property non-enumerable so it's not included in state. This prevents state store errors caused by large sql files.
+  Object.defineProperty(file, "sql", { enumerable: false });
+  return file;
+}
+
+const getPrefix = (name: string) => {
+  const prefix = name.split("_")[0];
+  const num = Number.parseInt(prefix, 10);
+  return Number.isNaN(num) ? null : num;
+};

package/src/neon/branch.ts

@@ -1,6 +1,8 @@
+import { alchemy } from "../alchemy.ts";
 import type { Context } from "../context.ts";
 import { Resource } from "../resource.ts";
 import { createNeonApi, type NeonApiOptions } from "./api.ts";
+import type { NeonClient } from "./api/sdk.gen.ts";
 import type * as neon from "./api/types.gen.ts";
 import type { NeonProject } from "./project.ts";
 import {
@@ -41,6 +43,10 @@ export interface NeonBranchProps extends NeonApiOptions {
    * The timestamp must be provided in ISO 8601 format; for example: `2024-02-26T12:00:00Z`.
    */
   parentTimestamp?: string;
+  /**
+   * When `true`, will adopt an existing branch by `name`.
+   */
+  adopt?: boolean;
   /**
    * The timestamp when the branch is scheduled to expire and be automatically deleted.
    * Must be set by the client following the [RFC 3339, section 5.6](https://tools.ietf.org/html/rfc3339#section-5.6) format with precision up to seconds (such as 2025-06-09T18:02:16Z).
@@ -182,6 +188,16 @@ export const NeonBranch = Resource(
         return this.destroy();
       }
       case "create": {
+        if (this.scope.adopt || props.adopt) {
+          try {
+            return await fetchBranch(api, { ...props, projectId, name });
+          } catch (error) {
+            if (!(error instanceof NeonBranchNotFound)) {
+              throw error;
+            }
+            // branch not found, continue with creation
+          }
+        }
         const { data } = await api.createProjectBranch({
           path: {
             project_id: projectId,
@@ -277,3 +293,121 @@ export const NeonBranch = Resource(
     }
   },
 );
+
+async function fetchBranch(
+  api: NeonClient,
+  props: NeonBranchProps & { name: string; projectId: string },
+): Promise<NeonBranch> {
+  const branchList: neon.Branch[] = [];
+
+  let branchesResponse = await api.listProjectBranches({
+    path: { project_id: props.projectId },
+    query: {
+      search: props.name,
+    },
+  });
+  branchList.push(...(branchesResponse.data?.branches ?? []));
+
+  while (branchesResponse.data?.pagination?.next) {
+    branchesResponse = await api.listProjectBranches({
+      path: { project_id: props.projectId },
+      query: {
+        search: props.name,
+        cursor: branchesResponse.data.pagination.next,
+      },
+    });
+    branchList.push(...(branchesResponse.data?.branches ?? []));
+  }
+
+  const branchesMatchingName = branchList.filter((b) => b.name === props.name);
+
+  if (branchesMatchingName.length === 0) {
+    throw new NeonBranchNotFound(props.name);
+  }
+
+  if (branchesMatchingName.length > 1) {
+    throw new Error(
+      `Multiple branches found with name "${props.name}". Name must be unique when adopting a branch.`,
+    );
+  }
+
+  const branch = branchesMatchingName[0];
+
+  const databases = await api.listProjectBranchDatabases({
+    path: {
+      branch_id: branch.id,
+      project_id: props.projectId,
+    },
+  });
+
+  const endpoints = await api.listProjectBranchEndpoints({
+    path: { project_id: props.projectId, branch_id: branch.id },
+  });
+
+  const roles = await api.listProjectBranchRoles({
+    path: {
+      project_id: props.projectId,
+      branch_id: branch.id,
+    },
+  });
+
+  const connectionUris: NeonConnectionUri[] = await Promise.all(
+    databases.data.databases.map((database) =>
+      api
+        .getConnectionUri({
+          path: { project_id: props.projectId },
+          query: {
+            branch_id: branch.id,
+            database_name: database.name,
+            role_name: database.owner_name,
+            pooled: false,
+          },
+        })
+        .then((res) => {
+          const url = new URL(res.data.uri);
+          return {
+            connection_uri: alchemy.secret(res.data.uri),
+            connection_parameters: {
+              database: database.name,
+              host: url.host,
+              port: 5432,
+              user: url.username,
+              password: alchemy.secret(url.password),
+            },
+          };
+        }),
+    ),
+  );
+
+  return {
+    id: branch.id,
+    projectId: branch.project_id,
+    createdAt: new Date(branch.created_at),
+    updatedAt: new Date(branch.updated_at),
+    expiresAt: branch.expires_at ? new Date(branch.expires_at) : undefined,
+    initSource: branch.init_source as "schema-only" | "parent-data" | undefined,
+    name: branch.name,
+    protected: branch.protected,
+    default: branch.default,
+    parentBranchId: branch.parent_id,
+    parentTimestamp: branch.parent_timestamp,
+    parentLsn: branch.parent_lsn,
+    roles: roles.data.roles.map(formatRole),
+    endpoints: endpoints.data.endpoints,
+    databases: databases.data.databases,
+    connectionUris,
+  };
+}
+
+export interface NeonConnectionUriProps extends NeonApiOptions {
+  projectId: string;
+  branchId: string;
+  databaseName: string;
+  roleName: string;
+}
+
+class NeonBranchNotFound extends Error {
+  constructor(name: string) {
+    super(`Branch ${name} not found`);
+  }
+}

package/src/state/d1-state-store.ts

@@ -78,12 +78,11 @@ const upsertDatabase = async (api: CloudflareApi, databaseName: string) => {
   const { listDatabases, createDatabase } = await import(
     "../cloudflare/d1-database.ts"
   );
-  const { applyMigrations, listMigrationsFiles } = await import(
-    "../cloudflare/d1-migrations.ts"
-  );
+  const { listSqlFiles } = await import("../cloudflare/d1-sql-file.ts");
+  const { applyMigrations } = await import("../cloudflare/d1-migrations.ts");
   const migrate = async (databaseId: string) => {
     await applyMigrations({
-      migrationsFiles: await listMigrationsFiles(MIGRATIONS_DIRECTORY),
+      migrationsFiles: await listSqlFiles(MIGRATIONS_DIRECTORY),
       migrationsTable: "migrations",
       accountId: api.accountId,
       databaseId,
@@ -93,17 +92,16 @@ const upsertDatabase = async (api: CloudflareApi, databaseName: string) => {
   };
   const databases = await listDatabases(api, databaseName);
   if (databases[0]) {
-    await migrate(databases[0].id);
+    await migrate(databases[0].uuid);
     return {
-      id: databases[0].id,
+      id: databases[0].uuid,
     };
   }
-  const res = await createDatabase(api, databaseName, {
+  const database = await createDatabase(api, databaseName, {
     readReplication: { mode: "disabled" },
   });
-  assert(res.result.uuid, "Missing UUID for database");
-  await migrate(res.result.uuid);
+  await migrate(database.uuid);
   return {
-    id: res.result.uuid,
+    id: database.uuid,
   };
 };

package/workers/tunnel-proxy.js

@@ -83,7 +83,7 @@ const renderErrorHtml = (props) => `
             Alchemy</a>.</p>
       </div>
       <div class="bg-slate-200 px-5 py-3 flex flex-col w-full max-w-lg">
-        <p class="text-sm text-slate-500">Alchemy 0.81.4</p>
+        <p class="text-sm text-slate-500">Alchemy 0.82.1</p>
       </div>
     </div>
   </body>