alchemy 0.56.0 → 0.57.1

package/src/cloudflare/website.ts

@@ -1,114 +1,110 @@
+import assert from "node:assert";
+import { spawn } from "node:child_process";
+import { once } from "node:events";
+import fs from "node:fs/promises";
 import path from "node:path";
 import { alchemy } from "../alchemy.ts";
-import { Exec } from "../os/exec.ts";
+import { Exec } from "../os/index.ts";
 import { Scope } from "../scope.ts";
-import { isSecret } from "../secret.ts";
-import { detectPackageManager } from "../util/detect-package-manager.ts";
+import { isSecret, type Secret } from "../secret.ts";
+import { dedent } from "../util/dedent.ts";
+import { DeferredPromise } from "../util/deferred-promise.ts";
+import { exists } from "../util/exists.ts";
+import { logger } from "../util/logger.ts";
 import { Assets } from "./assets.ts";
 import type { Bindings } from "./bindings.ts";
 import { DEFAULT_COMPATIBILITY_DATE } from "./compatibility-date.gen.ts";
-import { Worker, type AssetsConfig, type WorkerProps } from "./worker.ts";
+import { DEFAULT_PERSIST_PATH } from "./miniflare/paths.ts";
+import { type AssetsConfig, Worker, type WorkerProps } from "./worker.ts";
 import { WranglerJson, type WranglerJsonSpec } from "./wrangler.json.ts";
 
 export interface WebsiteProps<B extends Bindings>
-  extends Omit<WorkerProps<B>, "name" | "assets" | "entrypoint"> {
+  extends Omit<WorkerProps<B>, "assets" | "dev"> {
   /**
-   * The command to run to build the site
+   * Configuration for the build command
    *
-   * If one is not provided, the build is assumed to have already happened.
+   * If not provided, the build is assumed to have already happened.
    */
-  command?: string;
-
-  /**
-   * Additional environment variables to set when running the command
-   */
-  commandEnv?: Record<string, string>;
-
-  /**
-   * Whether to memoize the command (only re-run if the command changes)
-   *
-   * When set to `true`, the command will only be re-executed if the command string changes.
-   *
-   * When set to an object with `patterns`, the command will be re-executed if either:
-   * 1. The command string changes, or
-   * 2. The contents of any files matching the glob patterns change
-   *
-   * ⚠️ **Important Note**: When using memoization with build commands, the build outputs
-   * will not be produced if the command is memoized. This is because the command is not
-   * actually executed when memoized. Consider disabling memoization in CI environments:
-   *
-   * @example
-   * // Disable memoization in CI to ensure build outputs are always produced
-   * await Website("my-website", {
-   *   command: "vite build",
-   *   memoize: process.env.CI ? false : {
-   *     patterns: ["./src/**"]
-   *   }
-   * });
-   *
-   * @default false
-   */
-  memoize?: boolean | { patterns: string[] };
-
-  /**
-   * The name of the worker
-   *
-   * @default id
-   */
-  name?: string;
-  /**
-   * The entrypoint to your server
-   *
-   * @default - a simple server that serves static assets is generated
-   */
-  main?: string;
-  /**
-   * The directory containing your static assets
-   *
-   * @default "./dist"
-   */
-  assets?:
+  build?:
     | string
-    | ({
-        dist?: string;
-      } & AssetsConfig);
-  /**
-   * @default process.cwd()
-   */
-  cwd?: string;
-
+    | {
+        /**
+         * The command to run to build the site
+         */
+        command: string;
+        /**
+         * Additional environment variables to set when running the build command
+         */
+        env?: Record<string, string>;
+        /**
+         * Whether to memoize the command (only re-run if the command changes)
+         *
+         * When set to `true`, the command will only be re-executed if the command string changes.
+         *
+         * When set to an object with `patterns`, the command will be re-executed if either:
+         * 1. The command string changes, or
+         * 2. The contents of any files matching the glob patterns change
+         *
+         * ⚠️ **Important Note**: When using memoization with build commands, the build outputs
+         * will not be produced if the command is memoized. This is because the command is not
+         * actually executed when memoized. Consider disabling memoization in CI environments:
+         *
+         * @example
+         * // Disable memoization in CI to ensure build outputs are always produced
+         * await Website("my-website", {
+         *   command: "vite build",
+         *   memoize: process.env.CI ? false : {
+         *     patterns: ["./src/**"]
+         *   }
+         * });
+         *
+         * @default false
+         */
+        memoize?: boolean | { patterns: string[] };
+      };
   /**
-   * Write a wrangler.jsonc file
-   *
-   * @default - no wrangler.jsonc file is written
+   * Configuration for the dev command
    */
-  wrangler?:
-    | boolean
+  dev?:
     | string
     | {
-        path?: string;
-        // override main
-        main?: string;
+        /**
+         * The command to run to start the dev server
+         */
+        command: string;
+        /**
+         * Additional environment variables to set when running the dev command
+         */
+        env?: Record<string, string>;
       };
-
+  /**
+   * The directory containing static assets
+   *
+   * @default dist
+   */
+  assets?: string | ({ directory?: string } & AssetsConfig);
   /**
    * Configures default routing to support client-side routing for Single Page Applications (SPA)
    *
    * @default false
    */
   spa?: boolean;
-
-  /**
-   * Configure the command to use in development mode
-   */
-  dev?: {
-    command: string;
-  };
-
   /**
-   * Transform hooks to modify generated configuration files
+   * Configuration for the wrangler.json file
    */
-  transform?: {
+  wrangler?: {
+    /**
+     * Path to the wrangler.json file
+     *
+     * @default .alchemy/local/wrangler.jsonc
+     */
+    path?: string;
+    /**
+     * The main entry point for the worker
+     *
+     * @default worker.entrypoint
+     */
+    main?: string;
     /**
      * Hook to modify the wrangler.json object before it's written
      *
@@ -119,20 +115,33 @@ export interface WebsiteProps<B extends Bindings>
      * @param spec - The generated wrangler.json specification
      * @returns The modified wrangler.json specification
      */
-    wrangler?: (
+    transform?: (
       spec: WranglerJsonSpec,
     ) => WranglerJsonSpec | Promise<WranglerJsonSpec>;
+    /**
+     * Whether to include secrets in the wrangler.json file
+     *
+     * @default true if no path is specified, false otherwise
+     */
+    secrets?: boolean;
   };
-}
 
-const packageManager = await detectPackageManager();
-const devCommand = {
-  npm: "npx vite dev",
-  bun: "bun vite dev",
-  pnpm: "pnpm vite dev",
-  yarn: "yarn vite dev",
-  deno: "deno task dev",
-}[packageManager];
+  /**
+   * The command to run to build the site.
+   * @deprecated Use `build` or `build.command` instead
+   */
+  command?: string;
+  /**
+   * Additional environment variables to set when running the build command.
+   * @deprecated Use `build.env` instead
+   */
+  commandEnv?: Record<string, string>;
+  /**
+   * Whether to memoize the command (only re-run if the command changes)
+   * @deprecated Use `build.memoize` instead
+   */
+  memoize?: boolean | { patterns: string[] };
+}
 
 export type Website<B extends Bindings> = B extends { ASSETS: any }
   ? never
@@ -141,128 +150,294 @@ export type Website<B extends Bindings> = B extends { ASSETS: any }
 export async function Website<B extends Bindings>(
   id: string,
   props: WebsiteProps<B>,
-): Promise<Website<B>> {
-  if (props.bindings?.ASSETS) {
-    throw new Error("ASSETS binding is reserved for internal use");
+) {
+  const {
+    name = id,
+    build: buildProps,
+    assets,
+    dev,
+    script,
+    spa = true,
+    command,
+    commandEnv,
+    memoize,
+    ...workerProps
+  } = props;
+
+  assert(
+    !workerProps.bindings?.ASSETS,
+    "ASSETS binding is reserved for internal use",
+  );
+  if (command) {
+    logger.warnOnce(
+      "[website] The `command` prop is deprecated. Use `build.command` instead.",
+    );
+  }
+  if (commandEnv) {
+    logger.warnOnce(
+      "[website] The `commandEnv` prop is deprecated. Use `build.env` instead.",
+    );
+  }
+  if (memoize) {
+    logger.warnOnce(
+      "[website] The `memoize` prop is deprecated. Use `build.memoize` instead.",
+    );
   }
-  const wrangler = props.wrangler ?? true;
 
-  return alchemy.run(
-    id,
-    {
-      parent: Scope.current,
+  const build = (() => {
+    if (typeof buildProps === "string") {
+      return { command: buildProps, env: commandEnv, memoize };
+    }
+    if (buildProps) {
+      return buildProps;
+    }
+    if (command) {
+      return {
+        command,
+        env: commandEnv,
+        memoize,
+      };
+    }
+    return undefined;
+  })();
+  const paths = (() => {
+    const cwd = props.cwd ?? process.cwd();
+    return {
+      cwd,
+      assets: path.resolve(
+        cwd,
+        typeof assets === "string" ? assets : (assets?.directory ?? "dist"),
+      ),
+      local: path.resolve(cwd, ".alchemy/local"),
+      entrypoint: path.resolve(
+        cwd,
+        props.entrypoint ?? ".alchemy/local/worker.js",
+      ),
+      get wrangler() {
+        return {
+          path: path.resolve(
+            cwd,
+            props.wrangler?.path ?? ".alchemy/local/wrangler.jsonc",
+          ),
+          main: props.wrangler?.main
+            ? path.resolve(cwd, props.wrangler.main)
+            : this.entrypoint,
+        };
+      },
+    };
+  })();
+  const secrets = props.wrangler?.secrets ?? !props.wrangler?.path;
+  const env = {
+    ...(process.env ?? {}),
+    ...(props.env ?? {}),
+    ...Object.fromEntries(
+      Object.entries(props.bindings ?? {}).flatMap(([key, value]) => {
+        if (typeof value === "string" || (isSecret(value) && secrets)) {
+          return [[key, value]];
+        }
+        return [];
+      }),
+    ),
+  };
+  const worker = {
+    ...workerProps,
+    name,
+    cwd: path.relative(process.cwd(), paths.cwd),
+    compatibilityDate:
+      workerProps.compatibilityDate ?? DEFAULT_COMPATIBILITY_DATE,
+    assets: {
+      html_handling: "auto-trailing-slash",
+      not_found_handling: spa ? "single-page-application" : "none",
+      run_worker_first: false,
+      ...(typeof props.assets === "string" ? {} : props.assets),
     },
-    async (scope) => {
-      const cwd = path.resolve(props.cwd || process.cwd());
+    entrypoint: path.relative(paths.cwd, paths.entrypoint),
+  } as WorkerProps<B> & { name: string };
 
-      function resolveAbsPath<S extends string | undefined>(f: S): S {
-        return (
-          f ? (path.isAbsolute(f) ? f : path.resolve(cwd, f)) : undefined
-        ) as S;
-      }
+  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);
+    }
 
-      const mainPath = resolveAbsPath(props.main);
-      const assetsDirPath = resolveAbsPath(
-        typeof props.assets === "string"
-          ? props.assets
-          : (props.assets?.dist ?? "dist"),
-      );
-      const wranglerJsonPath = resolveAbsPath(
-        typeof wrangler === "boolean"
-          ? "wrangler.jsonc"
-          : typeof wrangler === "string"
-            ? wrangler
-            : (wrangler?.path ?? "wrangler.jsonc"),
-      );
+    await writeMiniflareSymlink(paths.cwd);
 
-      const workerName = props.name ?? id;
+    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,
+      },
+    });
 
-      const workerProps = {
-        ...props,
-        compatibilityDate:
-          props.compatibilityDate ?? DEFAULT_COMPATIBILITY_DATE,
-        name: workerName,
-        cwd: path.relative(process.cwd(), cwd),
-        entrypoint: mainPath,
-        assets: {
-          html_handling: "auto-trailing-slash",
-          not_found_handling: props.spa ? "single-page-application" : "none",
-          run_worker_first: false,
-          ...(typeof props.assets === "string" ? {} : props.assets),
+    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",
         },
-        script: props.main
-          ? undefined
-          : `
-export default {
-  async fetch(request, env) {
-    return new Response("Not Found", { status: 404 });
-  },
-};`,
-        url: props.url ?? true,
-        adopt: props.adopt ?? true,
-        dev: {
-          command: props.dev?.command ?? devCommand,
+        memoize: typeof build === "object" ? build.memoize : undefined,
+      });
+    }
+
+    let url: string | undefined;
+    if (dev && scope.local) {
+      url = await runDevCommand(scope, {
+        id,
+        command: typeof dev === "string" ? dev : dev.command,
+        env: {
+          ...env,
+          ...(typeof dev === "object" ? dev.env : {}),
         },
-      } as WorkerProps<any> & { name: string };
+        cwd: paths.cwd,
+      });
+    }
 
-      if (wrangler) {
-        const wranglerAbsPath = path.resolve(cwd, wranglerJsonPath);
-        const wranglerAbsDir = path.dirname(wranglerAbsPath);
+    return (await Worker("worker", {
+      ...worker,
+      bindings: {
+        ...worker.bindings,
+        ...(!scope.local
+          ? {
+              ASSETS: await Assets("assets", {
+                path: path.relative(process.cwd(), paths.assets),
+              }),
+            }
+          : {}),
+      },
+      dev: url ? { url } : undefined,
+    })) as Website<B>;
+  });
+}
 
-        await WranglerJson("wrangler.jsonc", {
-          path: path.relative(cwd, wranglerJsonPath),
-          worker: workerProps,
-          // @ts-expect-error - props.wrangler can be string | object, this is fine
-          main: props.wrangler?.main ?? props.main,
-          // hard-code the assets directory because we haven't yet included the assets binding
-          assets: {
-            binding: "ASSETS",
-            // path must be relative to the wrangler.jsonc file
-            directory: path.relative(wranglerAbsDir, assetsDirPath),
-          },
-          transform: props.transform,
-        });
-      }
+async function writeMiniflareSymlink(cwd: string) {
+  const target = path.resolve(DEFAULT_PERSIST_PATH);
+  await fs.mkdir(target, { recursive: true });
 
-      const isDev = scope.local;
+  if (cwd === process.cwd()) {
+    return;
+  }
 
-      if (props.command && !isDev) {
-        await Exec("build", {
-          cwd,
-          command: props.command,
-          env: {
-            ...(process.env ?? {}),
-            ...(props.env ?? {}),
-            ...(props.commandEnv ?? {}),
-            ...Object.fromEntries(
-              Object.entries(props.bindings ?? {}).flatMap(([key, value]) => {
-                if (isSecret(value)) {
-                  return [[key, value.unencrypted]];
-                } else if (typeof value === "string") {
-                  return [[key, value]];
-                }
-                return [];
-              }),
-            ),
-          },
-          memoize: props.memoize,
-        });
-      }
+  const persistPath = path.resolve(cwd, DEFAULT_PERSIST_PATH);
+  await fs.mkdir(path.dirname(persistPath), { recursive: true });
+  await fs.symlink(target, persistPath).catch((e) => {
+    if (e.code !== "EEXIST") {
+      throw e;
+    }
+  });
+}
 
-      return (await Worker("worker", {
-        ...workerProps,
-        bindings: {
-          ...workerProps.bindings,
-          // we don't include the Assets binding until after build to make sure the asset manifest is correct
-          // we generate the wrangler.json using all the bind
-          ASSETS: isDev
-            ? undefined
-            : await Assets("assets", {
-                // Assets are discovered from proces.cwd(), not Website.cwd or wrangler.jsonc
-                path: path.relative(process.cwd(), assetsDirPath),
-              }),
-        },
-      } as WorkerProps<any> & { name: string })) as Website<B>;
+async function runDevCommand(
+  scope: Scope,
+  props: {
+    id: string;
+    command: string;
+    env: Record<string, string | Secret<string> | undefined>;
+    cwd?: string;
+  },
+) {
+  const persistFile = path.join(process.cwd(), ".alchemy", `${props.id}.pid`);
+  if (await exists(persistFile)) {
+    const pid = Number.parseInt(await fs.readFile(persistFile, "utf8"));
+    try {
+      // Actually kill the process if it's alive
+      process.kill(pid, "SIGTERM");
+    } catch {
+      // ignore
+    }
+    try {
+      await fs.unlink(persistFile);
+    } catch {
+      // ignore
+    }
+  }
+  const command = props.command.split(" ");
+  const [cmd, ...args] = command;
+
+  const childProcess = spawn(cmd, args, {
+    cwd: props.cwd,
+    shell: true,
+    env: {
+      FORCE_COLOR: "1",
+      ...process.env,
+      ...Object.fromEntries(
+        Object.entries(props.env ?? {}).flatMap(([key, value]) => {
+          if (isSecret(value)) {
+            return [[key, value.unencrypted]];
+          }
+          if (typeof value === "string") {
+            return [[key, value]];
+          }
+          return [];
+        }),
+      ),
     },
-  );
+    stdio: "pipe",
+  });
+  await once(childProcess, "spawn");
+  scope.onCleanup(async () => {
+    if (childProcess.exitCode === null && !childProcess.killed) {
+      childProcess.kill("SIGTERM");
+      await Promise.any([
+        once(childProcess, "exit"),
+        new Promise((resolve) => setTimeout(resolve, 5000)),
+      ]);
+      if (!childProcess.killed) {
+        childProcess.kill("SIGKILL");
+      }
+    }
+    try {
+      await fs.unlink(persistFile);
+    } catch {
+      // ignore
+    }
+  });
+  if (childProcess.pid) {
+    await fs.mkdir(path.dirname(persistFile), { recursive: true });
+    await fs.writeFile(persistFile, childProcess.pid.toString());
+  }
+  const URL_REGEX =
+    /http:\/\/(?:(?:localhost|0\.0\.0\.0|127\.0\.0\.1)|(?:\d{1,3}\.){3}\d{1,3}):\d+(?:\/)?/;
+  const promise = new DeferredPromise<string>();
+  childProcess.stdout.on("data", (data) => {
+    if (promise.status === "pending") {
+      const match = data
+        .toString()
+        .replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "")
+        .match(URL_REGEX);
+      if (match) {
+        promise.resolve(match[0]);
+      }
+    }
+    process.stdout.write(data);
+  });
+  childProcess.stderr.on("data", (data) => {
+    process.stderr.write(data);
+  });
+
+  return await Promise.race([
+    promise.value,
+    once(childProcess, "exit").then(([code, signal]) => {
+      throw new Error(
+        `Dev command "${props.command}" for "${props.id}" failed to start (code: ${code}, signal: ${signal})`,
+      );
+    }),
+  ]);
 }