alchemy 0.63.1 → 0.65.0

package/src/cloudflare/hyperdrive.ts

@@ -4,8 +4,16 @@ import { Resource } from "../resource.ts";
 import { Scope } from "../scope.ts";
 import { Secret } from "../secret.ts";
 import { logger } from "../util/logger.ts";
-import { handleApiError } from "./api-error.ts";
-import { createCloudflareApi, type CloudflareApiOptions } from "./api.ts";
+import { CloudflareApiError, handleApiError } from "./api-error.ts";
+import {
+  extractCloudflareResult,
+  type CloudflareApiErrorPayload,
+} from "./api-response.ts";
+import {
+  createCloudflareApi,
+  type CloudflareApi,
+  type CloudflareApiOptions,
+} from "./api.ts";
 
 /**
  * Origin configuration for a PostgreSQL or MySQL database connection
@@ -163,6 +171,12 @@ export interface HyperdriveProps extends CloudflareApiOptions {
    */
   hyperdriveId?: string;
 
+  /**
+   * Whether to adopt an existing hyperdrive config
+   * @default false
+   */
+  adopt?: boolean;
+
   dev?: {
     /**
      * The database connection origin configuration for local development
@@ -176,46 +190,45 @@ export interface HyperdriveProps extends CloudflareApiOptions {
  * Output returned after Cloudflare Hyperdrive creation/update.
  * IMPORTANT: The interface name MUST match the exported resource name.
  */
-export interface Hyperdrive
-  extends Resource<"cloudflare::Hyperdrive">,
-    Omit<HyperdriveProps, "origin" | "dev"> {
-  /**
-   * The ID of the resource
-   */
-  id: string;
+export type Hyperdrive = Resource<"cloudflare::Hyperdrive"> &
+  Omit<HyperdriveProps, "origin" | "dev"> & {
+    /**
+     * The ID of the resource
+     */
+    id: string;
 
-  /**
-   * Name of the Hyperdrive configuration
-   */
-  name: string;
+    /**
+     * Name of the Hyperdrive configuration
+     */
+    name: string;
 
-  /**
-   * The Cloudflare-generated UUID of the hyperdrive
-   */
-  hyperdriveId: string;
+    /**
+     * The Cloudflare-generated UUID of the hyperdrive
+     */
+    hyperdriveId: string;
 
-  /**
-   * Database connection origin configuration
-   */
-  origin: HyperdrivePublicOrigin | HyperdriveOriginWithAccess;
+    /**
+     * Database connection origin configuration
+     */
+    origin: HyperdrivePublicOrigin | HyperdriveOriginWithAccess;
 
-  /**
-   * Local development configuration
-   * @internal
-   */
-  dev: {
     /**
-     * The connection string to use for local development
+     * Local development configuration
+     * @internal
      */
-    origin: Secret;
-  };
+    dev: {
+      /**
+       * The connection string to use for local development
+       */
+      origin: Secret;
+    };
 
-  /**
-   * Resource type identifier for binding.
-   * @internal
-   */
-  type: "hyperdrive";
-}
+    /**
+     * Resource type identifier for binding.
+     * @internal
+     */
+    type: "hyperdrive";
+  };
 
 /**
  * Represents a Cloudflare Hyperdrive configuration.
@@ -327,6 +340,7 @@ interface InternalHyperdriveProps extends CloudflareApiOptions {
     origin: Secret;
     force?: boolean;
   };
+  adopt?: boolean;
 }
 
 const _Hyperdrive = Resource(
@@ -337,7 +351,7 @@ const _Hyperdrive = Resource(
     props: InternalHyperdriveProps,
   ): Promise<Hyperdrive> {
     const hyperdriveId = props.hyperdriveId || this.output?.hyperdriveId;
-
+    const adopt = props.adopt || this.scope.adopt;
     const name =
       props.name ?? this.output?.name ?? this.scope.createPhysicalName(id);
 
@@ -354,13 +368,6 @@ const _Hyperdrive = Resource(
       });
     }
     const api = await createCloudflareApi(props);
-    const configsPath = `/accounts/${api.accountId}/hyperdrive/configs`;
-
-    // For create operations, we don't have a hyperdriveId yet
-    // For update/delete operations, we need to use the hyperdriveId from props or output
-    const configPath = hyperdriveId
-      ? `${configsPath}/${hyperdriveId}`
-      : `${configsPath}`;
 
     if (this.phase === "delete") {
       if (!hyperdriveId) {
@@ -369,7 +376,9 @@ const _Hyperdrive = Resource(
       }
 
       try {
-        const deleteResponse = await api.delete(configPath);
+        const deleteResponse = await api.delete(
+          `/accounts/${api.accountId}/hyperdrive/configs/${hyperdriveId}`,
+        );
         // Only swallow 404 Not Found errors, all other errors should be handled
         if (!deleteResponse.ok && deleteResponse.status !== 404) {
           await handleApiError(deleteResponse, "delete", "hyperdrive", id);
@@ -381,75 +390,107 @@ const _Hyperdrive = Resource(
       return this.destroy();
     }
 
-    let response: Response | undefined;
-    let apiResource: any;
-
     // Prepare request body with unwrapped secrets
-    const requestBody = prepareRequestBody(props);
-
-    try {
-      if (this.phase === "update" && hyperdriveId) {
-        // Update existing hyperdrive
-        response = await api.put(configPath, requestBody);
-      } else {
-        // Create new hyperdrive
-        if (hyperdriveId) {
-          // If we have a hyperdriveId but we're in create phase, it could be because
-          // the resource exists but wasn't in state. Do a GET to check.
-          const getResponse = await api.get(configPath);
-          if (getResponse.status === 200) {
-            // Hyperdrive exists, update it
-            logger.log(
-              `Hyperdrive '${id}' already exists. Updating existing resource.`,
+    const requestBody = prepareRequestBody({ ...props, name });
+    let result: HyperdriveResponse;
+
+    if (hyperdriveId) {
+      result = await extractCloudflareResult<HyperdriveResponse>(
+        `update hyperdrive config "${hyperdriveId}"`,
+        api.put(
+          `/accounts/${api.accountId}/hyperdrive/configs/${hyperdriveId}`,
+          requestBody,
+        ),
+      );
+    } else {
+      try {
+        result = await extractCloudflareResult<HyperdriveResponse>(
+          `create hyperdrive config "${name}"`,
+          api.post(
+            `/accounts/${api.accountId}/hyperdrive/configs`,
+            requestBody,
+          ),
+        );
+      } catch (error) {
+        if (
+          error instanceof CloudflareApiError &&
+          (error.errorData as CloudflareApiErrorPayload[]).some(
+            (e) => e.code === 2017, // 2017 is the error code for name conflict
+          )
+        ) {
+          if (!adopt) {
+            throw new Error(
+              `Hyperdrive config "${name}" already exists. Use adopt: true to adopt it.`,
+              { cause: error },
+            );
+          }
+          const existing = await findHyperdriveConfigByName(api, name);
+          if (!existing) {
+            throw new Error(
+              `Hyperdrive config "${name}" failed to create due to name conflict and could not be found for adoption.`,
+              { cause: error },
             );
-            response = await api.put(configPath, requestBody);
-          } else if (getResponse.status === 404) {
-            // Hyperdrive doesn't exist, create new
-            response = await api.post(configsPath, {
-              ...requestBody,
-              // Ensure name is set correctly if not already set
-              name: props.name || id,
-            });
-          } else {
-            // Unexpected error during GET check
-            await handleApiError(getResponse, "get", "hyperdrive", id);
           }
+          result = await extractCloudflareResult<HyperdriveResponse>(
+            `adopt hyperdrive config "${name}"`,
+            api.put(
+              `/accounts/${api.accountId}/hyperdrive/configs/${existing.id}`,
+              requestBody,
+            ),
+          );
         } else {
-          // No hyperdriveId, create new
-          response = await api.post(configsPath, {
-            ...requestBody,
-            // Ensure name is set correctly if not already set
-            name: props.name || id,
-          });
+          throw error;
         }
       }
-
-      if (!response?.ok) {
-        const action = this.phase === "update" ? "update" : "create";
-        await handleApiError(response!, action, "hyperdrive", id);
-      }
-
-      const data: { result: Record<string, any> } = await response!.json();
-      apiResource = data.result;
-    } catch (error) {
-      logger.error(`Error ${this.phase} Hyperdrive '${id}':`, error);
-      throw error;
     }
 
     // Construct the output object from API response and props
     return this({
       id,
-      hyperdriveId: apiResource.id, // Store the Cloudflare-assigned UUID
-      name: apiResource.name,
+      hyperdriveId: result.id, // Store the Cloudflare-assigned UUID
+      name: result.name,
       origin: props.origin,
-      caching: apiResource.caching,
-      mtls: apiResource.mtls,
+      caching: result.caching,
+      mtls: result.mtls,
       dev: props.dev,
       type: "hyperdrive",
     });
   },
 );
 
+interface HyperdriveResponse {
+  id: string;
+  name: string;
+  origin: HyperdriveOrigin;
+  caching?: HyperdriveCaching;
+  created_on?: string;
+  modified_on?: string;
+  mtls?: HyperdriveMtls;
+  origin_connection_limit?: number;
+}
+
+async function findHyperdriveConfigByName(
+  api: CloudflareApi,
+  name: string,
+  page = 1,
+) {
+  const response = await api.get(
+    `/accounts/${api.accountId}/hyperdrive/configs?page=${page}`,
+  );
+  const data: {
+    result: HyperdriveResponse[];
+    result_info?: { total_pages?: number };
+  } = await response.json();
+  const found = data.result.find((config) => config.name === name);
+  if (found) {
+    return found;
+  }
+  if (data.result_info?.total_pages && page < data.result_info.total_pages) {
+    return await findHyperdriveConfigByName(api, name, page + 1);
+  }
+  return null;
+}
+
 /**
  * Prepare the request body by unwrapping secret values
  */

package/src/cloudflare/index.ts

@@ -33,6 +33,7 @@ export * from "./email-rule.ts";
 export * from "./hyperdrive.ts";
 export * from "./images.ts";
 export * from "./kv-namespace.ts";
+export * from "./next.ts";
 export * from "./nuxt/nuxt.ts";
 export * from "./orange.ts";
 export * from "./permission-groups.ts";

package/src/cloudflare/next.ts

@@ -0,0 +1,123 @@
+import * as fs from "node:fs/promises";
+import path from "node:path";
+import { bold, cyan } 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(
+      [
+        bold(
+          `The ${cyan("wrangler.jsonc")} file for Next.js ${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/website.ts

@@ -1,7 +1,6 @@
 import assert from "node:assert";
 import fs from "node:fs/promises";
 import path from "node:path";
-import { alchemy } from "../alchemy.ts";
 import { Exec } from "../os/index.ts";
 import { Scope } from "../scope.ts";
 import { isSecret } from "../secret.ts";
@@ -255,101 +254,101 @@ export async function Website<B extends Bindings>(
     entrypoint: path.relative(paths.cwd, paths.entrypoint),
   } as WorkerProps<B> & { name: string };
 
-  return await alchemy.run(id, { parent: Scope.current }, async (scope) => {
-    if (!workerProps.entrypoint) {
-      await fs.mkdir(path.dirname(paths.entrypoint), { recursive: true });
-      const content =
-        script ??
-        dedent`
-        export default {
-            async fetch(request, env) {
-                return new Response("Not Found", { status: 404 });
-            },
-        };`;
-      await fs.writeFile(paths.entrypoint, content);
-    }
+  if (!workerProps.entrypoint) {
+    await fs.mkdir(path.dirname(paths.entrypoint), { recursive: true });
+    const content =
+      script ??
+      dedent`
+      export default {
+          async fetch(request, env) {
+              return new Response("Not Found", { status: 404 });
+          },
+      };`;
+    await fs.writeFile(paths.entrypoint, content);
+  }
 
-    await writeMiniflareSymlink(paths.cwd);
+  await writeMiniflareSymlink(paths.cwd);
 
-    await WranglerJson("wrangler.jsonc", {
-      path: path.relative(paths.cwd, paths.wrangler.path),
-      worker,
-      assets: {
-        binding: "ASSETS",
-        directory: path.relative(paths.cwd, paths.assets),
-      },
-      main: path.relative(paths.cwd, paths.wrangler.main),
-      secrets,
-      transform: {
-        wrangler: props.wrangler?.transform,
-      },
-    });
+  await WranglerJson({
+    path: path.relative(paths.cwd, paths.wrangler.path),
+    worker,
+    assets: {
+      binding: "ASSETS",
+      directory: path.relative(paths.cwd, paths.assets),
+    },
+    main: path.relative(paths.cwd, paths.wrangler.main),
+    secrets,
+    transform: {
+      wrangler: props.wrangler?.transform,
+    },
+  });
 
-    if (build && !scope.local) {
-      await Exec("build", {
-        cwd: path.relative(process.cwd(), paths.cwd),
-        command: build.command,
-        env: {
-          ...env,
-          ...(typeof build === "object" ? build.env : {}),
-          NODE_ENV: "production",
-        },
-        memoize: typeof build === "object" ? build.memoize : undefined,
-      });
-    }
+  const scope = Scope.current;
 
-    let url: string | undefined;
-    if (dev && scope.local) {
-      url = await scope.spawn(name, {
-        cmd: typeof dev === "string" ? dev : dev.command,
-        cwd: paths.cwd,
-        extract: (line) => {
-          const URL_REGEX =
-            /http:\/\/(localhost|0\.0\.0\.0|127\.0\.0\.1|\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}):\d+\/?/;
-          const match = line
-            .replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "")
-            .match(URL_REGEX);
-          if (match) {
-            return match[0];
-          }
-        },
-        env: {
-          ...Object.fromEntries(
-            Object.entries(env ?? {}).flatMap(([key, value]) => {
-              if (isSecret(value)) {
-                return [[key, value.unencrypted]];
-              }
-              if (typeof value === "string") {
-                return [[key, value]];
-              }
-              return [];
-            }),
-          ),
-          ...(typeof dev === "object" ? dev.env : {}),
-          FORCE_COLOR: "1",
-          ...process.env,
-          // NOTE: we must set this to ensure the user does not accidentally set `NODE_ENV=production`
-          // which breaks `vite dev` (it won't, for example, re-write `process.env.TSS_APP_BASE` in the `.js` client side bundle)
-          NODE_ENV: "development",
-        },
-      });
-    }
+  if (build && !scope.local) {
+    await Exec(`${id}-build`, {
+      cwd: path.relative(process.cwd(), paths.cwd),
+      command: build.command,
+      env: {
+        ...env,
+        ...(typeof build === "object" ? build.env : {}),
+        NODE_ENV: "production",
+      },
+      memoize: typeof build === "object" ? build.memoize : undefined,
+    });
+  }
 
-    return (await Worker("worker", {
-      ...worker,
-      bindings: {
-        ...worker.bindings,
-        ...(!scope.local
-          ? {
-              ASSETS: await Assets("assets", {
-                path: path.relative(process.cwd(), paths.assets),
-              }),
+  let url: string | undefined;
+  if (dev && scope.local) {
+    url = await scope.spawn(name, {
+      cmd: typeof dev === "string" ? dev : dev.command,
+      cwd: paths.cwd,
+      extract: (line) => {
+        const URL_REGEX =
+          /http:\/\/(localhost|0\.0\.0\.0|127\.0\.0\.1|\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}):\d+\/?/;
+        const match = line
+          .replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "")
+          .match(URL_REGEX);
+        if (match) {
+          return match[0];
+        }
+      },
+      env: {
+        ...Object.fromEntries(
+          Object.entries(env ?? {}).flatMap(([key, value]) => {
+            if (isSecret(value)) {
+              return [[key, value.unencrypted]];
+            }
+            if (typeof value === "string") {
+              return [[key, value]];
             }
-          : {}),
+            return [];
+          }),
+        ),
+        ...(typeof dev === "object" ? dev.env : {}),
+        FORCE_COLOR: "1",
+        ...process.env,
+        // NOTE: we must set this to ensure the user does not accidentally set `NODE_ENV=production`
+        // which breaks `vite dev` (it won't, for example, re-write `process.env.TSS_APP_BASE` in the `.js` client side bundle)
+        NODE_ENV: "development",
       },
-      dev: url ? { url } : undefined,
-    })) as Website<B>;
-  });
+    });
+  }
+
+  return (await Worker(id, {
+    ...worker,
+    bindings: {
+      ...worker.bindings,
+      ...(!scope.local
+        ? {
+            ASSETS: await Assets("assets", {
+              path: path.relative(process.cwd(), paths.assets),
+            }),
+          }
+        : {}),
+    },
+    dev: url ? { url } : undefined,
+  })) as Website<B>;
 }
 
 async function writeMiniflareSymlink(cwd: string) {