alchemy 0.78.0 → 0.80.0

package/src/docker/volume.ts

@@ -43,6 +43,12 @@ export interface VolumeProps {
    * Custom metadata labels for the volume
    */
   labels?: VolumeLabel[] | Record<string, string>;
+
+  /**
+   * Whether to adopt the volume if it already exists
+   * @default false
+   */
+  adopt?: boolean;
 }
 
 /**
@@ -133,33 +139,64 @@ export const Volume = Resource(
 
       // Return destroyed state
       return this.destroy();
-    } else {
-      // Set default driver if not provided
-      const driver = props.driver || "local";
-      const driverOpts = props.driverOpts || {};
-
-      // Create the volume
-      const volumeId = await api.createVolume(
-        volumeName,
-        driver,
-        driverOpts,
-        processedLabels,
-      );
-
-      // Get volume details to retrieve mountpoint
-      const volumeInfos = await api.inspectVolume(volumeId);
-      const mountpoint = volumeInfos[0].Mountpoint;
-
-      return {
-        ...props,
-        driver: driver,
-        id: volumeId,
-        name: volumeName,
-        mountpoint,
-        createdAt: Date.now(),
-        labels: Array.isArray(props.labels) ? props.labels : undefined,
-        driverOpts: props.driverOpts,
-      };
     }
+
+    // Check if volume already exists
+    const volumeExists = await api.volumeExists(volumeName);
+
+    if (volumeExists) {
+      if (this.phase === "update") {
+        this.replace();
+      } else {
+        // Create phase - check for adoption
+        if (!props.adopt) {
+          throw new Error(
+            `Volume "${volumeName}" already exists. Use adopt: true to adopt it.`,
+          );
+        }
+
+        // Adopt existing volume
+        const volumeInfos = await api.inspectVolume(volumeName);
+        const volumeInfo = volumeInfos[0];
+
+        return {
+          ...props,
+          id: volumeInfo.Name,
+          name: volumeInfo.Name,
+          driver: volumeInfo.Driver,
+          mountpoint: volumeInfo.Mountpoint,
+          createdAt: new Date(volumeInfo.CreatedAt).getTime(),
+          labels: Array.isArray(props.labels) ? props.labels : undefined,
+          driverOpts: volumeInfo.Options,
+        };
+      }
+    }
+
+    // Set default driver if not provided
+    const driver = props.driver || "local";
+    const driverOpts = props.driverOpts || {};
+
+    // Create the volume
+    const volumeId = await api.createVolume(
+      volumeName,
+      driver,
+      driverOpts,
+      processedLabels,
+    );
+
+    // Get volume details to retrieve mountpoint
+    const volumeInfos = await api.inspectVolume(volumeId);
+    const mountpoint = volumeInfos[0].Mountpoint;
+
+    return {
+      ...props,
+      driver: driver,
+      id: volumeId,
+      name: volumeName,
+      mountpoint,
+      createdAt: Date.now(),
+      labels: Array.isArray(props.labels) ? props.labels : undefined,
+      driverOpts: props.driverOpts,
+    };
   },
 );

package/src/neon/project.ts

@@ -1,13 +1,15 @@
+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 {
   formatConnectionUri,
   formatRole,
-  waitForOperations,
   type NeonConnectionUri,
   type NeonRole,
+  waitForOperations,
 } from "./utils.ts";
 
 /**
@@ -32,6 +34,18 @@ export type NeonPgVersion = 14 | 15 | 16 | 17 | 18;
  * Properties for creating or updating a Neon project
  */
 export interface NeonProjectProps extends NeonApiOptions {
+  /**
+   * When `true`, will adopt an existing project by `name`
+   */
+  adopt?: true;
+
+  /**
+   * Whether to delete the database when the resource is destroyed.
+   * When false, the database will only be removed from the state but not deleted via API.
+   * @default true, unless the resource was adopted
+   */
+  delete?: boolean;
+
   /**
    * Name of the project
    *
@@ -165,6 +179,13 @@ export interface NeonProject {
  * });
  *
  * @example
+ * // Adopt an existing Neon project by name:
+ * const project = await NeonProject("my-project", {
+ *   adopt: true
+ *   name: "adjective-noun-123",
+ * });
+ *
+ * @example
  * // Create a Neon project in a specific region with a specific PostgreSQL version:
  * const euProject = await NeonProject("my-eu-project", {
  *   name: "My EU Project",
@@ -193,6 +214,17 @@ export const NeonProject = Resource(
 
     switch (this.phase) {
       case "create": {
+        if (props.adopt) {
+          try {
+            return await fetchProject(api, { ...props, name });
+          } catch (error) {
+            if (!(error instanceof NeonProjectNotFound)) {
+              throw error;
+            }
+            // project not found, continue with creation
+          }
+        }
+
         const { data } = await api.createProject({
           body: {
             project: {
@@ -276,8 +308,9 @@ export const NeonProject = Resource(
           history_retention_seconds: data.project.history_retention_seconds,
         };
       }
+
       case "delete": {
-        if (this.output?.id) {
+        if (props.delete !== false && this.output?.id) {
           const response = await api.deleteProject({
             path: {
               project_id: this.output.id,
@@ -298,3 +331,125 @@ export const NeonProject = Resource(
     }
   },
 );
+
+/**
+ * References an existing Neon project by name. You can use this to reference an existing NeonProject without adopting it.
+ *
+ * @example
+ * const project = await NeonProjectRef({
+ *   name: "my-project"
+ * });
+ *
+ * @warning Project names must be unique when referencing existing projects. If multiple projects are found with the same name, an error will be thrown.
+ */
+export async function NeonProjectRef(
+  props: NeonProjectProps & { name: string },
+): Promise<NeonProject> {
+  return await fetchProject(createNeonApi(props), props);
+}
+
+async function fetchProject(
+  api: NeonClient,
+  props: NeonProjectProps & { name: string },
+): Promise<NeonProject> {
+  const project = await api
+    .listProjects({
+      query: { search: props.name },
+    })
+    .then(({ data: { projects } }) => {
+      if (!projects.length) {
+        throw new NeonProjectNotFound(props.name);
+      }
+      if (projects.length > 1) {
+        throw new Error(
+          `Multiple projects found with name "${props.name}". Name must be unique when referencing existing projects.`,
+        );
+      }
+      return projects[0];
+    });
+  const endpointsPromise = api
+    .listProjectEndpoints({
+      path: { project_id: project.id },
+    })
+    .then((res) => res.data.endpoints as [neon.Endpoint, ...neon.Endpoint[]]);
+  const branch = await api
+    .listProjectBranches({
+      path: { project_id: project.id },
+      query: { search: props.default_branch_name ?? "main" },
+    })
+    .then((res) => {
+      if (!res.data.branches.length) {
+        throw new Error(
+          `Branch ${props.default_branch_name ?? "main"} does not exist in Neon project "${props.name}" (${project.id}).`,
+        );
+      }
+      return res.data.branches[0];
+    });
+  const rolesPromise = api
+    .listProjectBranchRoles({
+      path: { project_id: project.id, branch_id: branch.id },
+    })
+    .then((res) => res.data.roles.map(formatRole) as [NeonRole, ...NeonRole[]]);
+  const databases = await api
+    .listProjectBranchDatabases({
+      path: { project_id: project.id, branch_id: branch.id },
+    })
+    .then((res) => res.data.databases as [neon.Database, ...neon.Database[]]);
+  const [connection_uris, endpoints, roles] = await Promise.all([
+    Promise.all(databases.map(fetchConnectionUri)) as Promise<
+      [NeonConnectionUri, ...NeonConnectionUri[]]
+    >,
+    endpointsPromise,
+    rolesPromise,
+  ]);
+  return {
+    id: project.id,
+    name: project.name,
+    created_at: project.created_at,
+    updated_at: project.updated_at,
+    proxy_host: project.proxy_host,
+    region_id: project.region_id as NeonRegion,
+    pg_version: project.pg_version as NeonPgVersion,
+    settings: project.settings,
+    default_endpoint_settings: project.default_endpoint_settings,
+    history_retention_seconds: project.history_retention_seconds ?? 86400,
+    connection_uris,
+    roles,
+    databases,
+    branch,
+    endpoints,
+  };
+
+  async function fetchConnectionUri(
+    database: neon.Database,
+  ): Promise<NeonConnectionUri> {
+    const {
+      data: { uri },
+    } = await api.getConnectionUri({
+      path: { project_id: project.id },
+      query: {
+        branch_id: database.branch_id,
+        database_name: database.name,
+        role_name: database.owner_name,
+        pooled: false, // match default behavior from create endpoint (should this be true?)
+      },
+    });
+    const url = new URL(uri);
+    return {
+      connection_uri: alchemy.secret(uri),
+      connection_parameters: {
+        database: database.name,
+        host: url.host,
+        port: 5432,
+        user: url.username,
+        password: alchemy.secret(url.password),
+      },
+    };
+  }
+}
+
+class NeonProjectNotFound extends Error {
+  constructor(name: string) {
+    super(`Failed to find existing project "${name}".`);
+  }
+}

package/src/util/camel-to-snake.ts

@@ -2,26 +2,41 @@ export interface LogPushProps {
   maxFooBar: string;
 }
 
-export function camelToSnakeObjectDeep<T extends object | undefined>(
+export function camelToSnakeObjectDeep<T>(
   obj: T,
-): T extends undefined ? undefined : CamelToSnake<T> {
-  return (
-    obj
-      ? Object.fromEntries(
-          Object.entries(obj).map(([key, value]) => [
-            key
-              .replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2") // Handle consecutive capitals: "FOOBar" -> "FOO_Bar"
-              .replace(/([a-z])([A-Z])/g, "$1_$2") // Handle normal camelCase: "fooBar" -> "foo_Bar"
-              .toLowerCase(),
-            Array.isArray(value)
-              ? value.map(camelToSnakeObjectDeep)
-              : typeof value === "object" && value !== null
-                ? camelToSnakeObjectDeep(value)
-                : value,
-          ]),
-        )
-      : undefined
-  ) as T extends undefined ? undefined : CamelToSnake<T>;
+): T extends undefined ? undefined : T extends object ? CamelToSnake<T> : T {
+  if (obj === undefined || obj === null) {
+    return obj as any;
+  }
+
+  // If it's not an object (primitive types), return as-is
+  if (typeof obj !== "object") {
+    return obj as any;
+  }
+
+  if (obj instanceof RegExp) {
+    return obj as any;
+  }
+
+  // Handle arrays
+  if (Array.isArray(obj)) {
+    return obj.map(camelToSnakeObjectDeep) as any;
+  }
+
+  // Handle objects
+  return Object.fromEntries(
+    Object.entries(obj).map(([key, value]) => [
+      key
+        .replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2") // Handle consecutive capitals: "FOOBar" -> "FOO_Bar"
+        .replace(/([a-z])([A-Z])/g, "$1_$2") // Handle normal camelCase: "fooBar" -> "foo_Bar"
+        .toLowerCase(),
+      Array.isArray(value)
+        ? value.map(camelToSnakeObjectDeep)
+        : typeof value === "object" && value !== null
+          ? camelToSnakeObjectDeep(value)
+          : value,
+    ]),
+  ) as any;
 }
 
 // Helper to check if a character is uppercase

package/src/util/find-open-port.ts

@@ -1,4 +1,22 @@
 import net from "node:net";
+import { AsyncMutex } from "./mutex.ts";
+
+const owners = new Map<string, number>();
+const ports = new Map<number, string>();
+
+const mutex = new AsyncMutex();
+
+export async function reservePort(key: string) {
+  if (owners.has(key)) {
+    return owners.get(key)!;
+  }
+  return mutex.lock(async () => {
+    const port = await findOpenPort();
+    owners.set(key, port);
+    ports.set(port, key);
+    return port;
+  });
+}
 
 export async function findOpenPort(min = 1337, max = 65535): Promise<number> {
   for (let port = min; port <= max; port++) {

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.78.0</p>
+        <p class="text-sm text-slate-500">Alchemy 0.80.0</p>
       </div>
     </div>
   </body>