wrangler 0.0.0-ece06ea → 0.0.0-ed08df4

package/src/dev/local.tsx

@@ -0,0 +1,312 @@
+import { spawn } from "node:child_process";
+import { realpathSync } from "node:fs";
+import { writeFile } from "node:fs/promises";
+import path from "node:path";
+import { useState, useEffect, useRef } from "react";
+import onExit from "signal-exit";
+import useInspector from "../inspect";
+import { logger } from "../logger";
+import { DEFAULT_MODULE_RULES } from "../module-collection";
+import { waitForPortToBeAvailable } from "../proxy";
+import type { Config } from "../config";
+import type { AssetPaths } from "../sites";
+import type { CfWorkerInit, CfScriptFormat } from "../worker";
+import type { EsbuildBundle } from "./use-esbuild";
+import type { MiniflareOptions } from "miniflare";
+
+interface LocalProps {
+  name: string | undefined;
+  bundle: EsbuildBundle | undefined;
+  format: CfScriptFormat | undefined;
+  compatibilityDate: string;
+  compatibilityFlags: string[] | undefined;
+  bindings: CfWorkerInit["bindings"];
+  assetPaths: AssetPaths | undefined;
+  public: string | undefined;
+  port: number;
+  ip: string;
+  rules: Config["rules"];
+  inspectorPort: number;
+  enableLocalPersistence: boolean;
+  crons: Config["triggers"]["crons"];
+}
+
+export function Local(props: LocalProps) {
+  const { inspectorUrl } = useLocalWorker(props);
+  useInspector({
+    inspectorUrl,
+    port: props.inspectorPort,
+    logToTerminal: false,
+  });
+  return null;
+}
+
+function useLocalWorker({
+  name: workerName,
+  bundle,
+  format,
+  compatibilityDate,
+  compatibilityFlags,
+  bindings,
+  assetPaths,
+  public: publicDirectory,
+  port,
+  rules,
+  enableLocalPersistence,
+  ip,
+  crons,
+}: LocalProps) {
+  // TODO: pass vars via command line
+  const local = useRef<ReturnType<typeof spawn>>();
+  const removeSignalExitListener = useRef<() => void>();
+  const [inspectorUrl, setInspectorUrl] = useState<string | undefined>();
+  // if we're using local persistence for data, we should use the cwd
+  // as an explicit path, or else it'll use the temp dir
+  // which disappears when dev ends
+  const localPersistencePath = enableLocalPersistence
+    ? // Maybe we could make the path configurable as well?
+      path.join(process.cwd(), "wrangler-local-state")
+    : // We otherwise choose null, but choose true later
+      // so that it's persisted in the temp dir across a dev session
+      // even when we change source and reload
+      null;
+  useEffect(() => {
+    const abortController = new AbortController();
+    async function startLocalWorker() {
+      if (!bundle || !format) return;
+
+      // port for the worker
+      await waitForPortToBeAvailable(port, {
+        retryPeriod: 200,
+        timeout: 2000,
+        abortSignal: abortController.signal,
+      });
+
+      if (publicDirectory) {
+        throw new Error(
+          '⎔ A "public" folder is not yet supported in local mode.'
+        );
+      }
+
+      // In local mode, we want to copy all referenced modules into
+      // the output bundle directory before starting up
+      for (const module of bundle.modules) {
+        await writeFile(
+          path.join(path.dirname(bundle.path), module.name),
+          module.content
+        );
+      }
+
+      const scriptPath = realpathSync(bundle.path);
+
+      // the wasm_modules/text_blobs/data_blobs bindings are
+      // relative to process.cwd(), but the actual worker bundle
+      // is in the temp output directory; so we rewrite the paths to be absolute,
+      // letting miniflare resolve them correctly
+
+      // wasm
+      const wasmBindings: Record<string, string> = {};
+      for (const [name, filePath] of Object.entries(
+        bindings.wasm_modules || {}
+      )) {
+        wasmBindings[name] = path.join(process.cwd(), filePath);
+      }
+
+      // text
+      const textBlobBindings: Record<string, string> = {};
+      for (const [name, filePath] of Object.entries(
+        bindings.text_blobs || {}
+      )) {
+        textBlobBindings[name] = path.join(process.cwd(), filePath);
+      }
+
+      // data
+      const dataBlobBindings: Record<string, string> = {};
+      for (const [name, filePath] of Object.entries(
+        bindings.data_blobs || {}
+      )) {
+        dataBlobBindings[name] = path.join(process.cwd(), filePath);
+      }
+
+      if (format === "service-worker") {
+        for (const { type, name } of bundle.modules) {
+          if (type === "compiled-wasm") {
+            // In service-worker format, .wasm modules are referenced by global identifiers,
+            // so we convert it here.
+            // This identifier has to be a valid JS identifier, so we replace all non alphanumeric
+            // characters with an underscore.
+            const identifier = name.replace(/[^a-zA-Z0-9_$]/g, "_");
+            wasmBindings[identifier] = name;
+          } else if (type === "text") {
+            // In service-worker format, text modules are referenced by global identifiers,
+            // so we convert it here.
+            // This identifier has to be a valid JS identifier, so we replace all non alphanumeric
+            // characters with an underscore.
+            const identifier = name.replace(/[^a-zA-Z0-9_$]/g, "_");
+            textBlobBindings[identifier] = name;
+          } else if (type === "buffer") {
+            // In service-worker format, data blobs are referenced by global identifiers,
+            // so we convert it here.
+            // This identifier has to be a valid JS identifier, so we replace all non alphanumeric
+            // characters with an underscore.
+            const identifier = name.replace(/[^a-zA-Z0-9_$]/g, "_");
+            dataBlobBindings[identifier] = name;
+          }
+        }
+      }
+
+      const options: MiniflareOptions = {
+        name: workerName,
+        port,
+        scriptPath,
+        host: ip,
+        modules: format === "modules",
+        modulesRules: (rules || [])
+          .concat(DEFAULT_MODULE_RULES)
+          .map(({ type, globs: include, fallthrough }) => ({
+            type,
+            include,
+            fallthrough,
+          })),
+        compatibilityDate,
+        compatibilityFlags,
+        kvNamespaces: bindings.kv_namespaces?.map((kv) => kv.binding),
+        durableObjects: Object.fromEntries(
+          (bindings.durable_objects?.bindings ?? []).map<[string, string]>(
+            (value) => [value.name, value.class_name]
+          )
+        ),
+        ...(localPersistencePath
+          ? {
+              kvPersist: path.join(localPersistencePath, "kv"),
+              durableObjectsPersist: path.join(localPersistencePath, "do"),
+              cachePersist: path.join(localPersistencePath, "cache"),
+            }
+          : {
+              // We mark these as true, so that they'll
+              // persist in the temp directory.
+              // This means they'll persist across a dev session,
+              // even if we change source and reload,
+              // and be deleted when the dev session ends
+              durableObjectsPersist: true,
+              cachePersist: true,
+              kvPersist: true,
+            }),
+
+        sitePath: assetPaths?.assetDirectory
+          ? path.join(assetPaths.baseDirectory, assetPaths.assetDirectory)
+          : undefined,
+        siteInclude: assetPaths?.includePatterns.length
+          ? assetPaths?.includePatterns
+          : undefined,
+        siteExclude: assetPaths?.excludePatterns.length
+          ? assetPaths.excludePatterns
+          : undefined,
+        bindings: bindings.vars,
+        wasmBindings,
+        textBlobBindings,
+        dataBlobBindings,
+        sourceMap: true,
+        logUnhandledRejections: true,
+        crons,
+      };
+
+      // The path to the Miniflare CLI assumes that this file is being run from
+      // `wrangler-dist` and that the CLI is found in `miniflare-dist`.
+      // If either of those paths change this line needs updating.
+      const miniflareCLIPath = path.resolve(
+        __dirname,
+        "../miniflare-dist/index.mjs"
+      );
+      const optionsArg = JSON.stringify(options, null);
+
+      logger.log("⎔ Starting a local server...");
+      local.current = spawn(
+        "node",
+        [
+          "--experimental-vm-modules", // ensures that Miniflare can run ESM Workers
+          "--no-warnings", // hide annoying Node warnings
+          "--inspect", // start Miniflare listening for a debugger to attach
+          miniflareCLIPath,
+          optionsArg,
+          // "--log=VERBOSE", // uncomment this to Miniflare to log "everything"!
+        ],
+        {
+          cwd: path.dirname(scriptPath),
+        }
+      );
+
+      local.current.on("close", (code) => {
+        if (code) {
+          logger.log(`Miniflare process exited with code ${code}`);
+        }
+      });
+
+      local.current.stdout?.on("data", (data: Buffer) => {
+        process.stdout.write(data);
+      });
+
+      local.current.stderr?.on("data", (data: Buffer) => {
+        const matches =
+          /Debugger listening on (ws:\/\/127\.0\.0\.1:\d+\/[A-Za-z0-9-]+)/.exec(
+            data.toString()
+          );
+        if (matches) {
+          setInspectorUrl(matches[1]);
+        }
+      });
+
+      local.current.on("exit", (code) => {
+        if (code) {
+          logger.error(`Miniflare process exited with code ${code}`);
+        }
+      });
+
+      local.current.on("error", (error: Error) => {
+        logger.error(`Miniflare process failed to spawn`);
+        logger.error(error);
+      });
+
+      removeSignalExitListener.current = onExit((_code, _signal) => {
+        logger.log("⎔ Shutting down local server.");
+        local.current?.kill();
+        local.current = undefined;
+      });
+    }
+
+    startLocalWorker().catch((err) => {
+      logger.error("local worker:", err);
+    });
+
+    return () => {
+      abortController.abort();
+      if (local.current) {
+        logger.log("⎔ Shutting down local server.");
+        local.current?.kill();
+        local.current = undefined;
+        removeSignalExitListener.current && removeSignalExitListener.current();
+        removeSignalExitListener.current = undefined;
+      }
+    };
+  }, [
+    bundle,
+    workerName,
+    format,
+    port,
+    ip,
+    bindings.durable_objects?.bindings,
+    bindings.kv_namespaces,
+    bindings.vars,
+    compatibilityDate,
+    compatibilityFlags,
+    localPersistencePath,
+    assetPaths,
+    publicDirectory,
+    rules,
+    bindings.wasm_modules,
+    bindings.text_blobs,
+    bindings.data_blobs,
+    crons,
+  ]);
+  return { inspectorUrl };
+}

package/src/dev/remote.tsx

@@ -0,0 +1,213 @@
+import assert from "node:assert";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { useState, useEffect, useRef } from "react";
+import { createWorkerPreview } from "../create-worker-preview";
+import useInspector from "../inspect";
+import { logger } from "../logger";
+import { usePreviewServer } from "../proxy";
+import { syncAssets } from "../sites";
+import type { CfPreviewToken } from "../create-worker-preview";
+import type { AssetPaths } from "../sites";
+import type { CfModule, CfWorkerInit, CfScriptFormat } from "../worker";
+import type { EsbuildBundle } from "./use-esbuild";
+
+export function Remote(props: {
+  name: string | undefined;
+  bundle: EsbuildBundle | undefined;
+  format: CfScriptFormat | undefined;
+  public: string | undefined;
+  assetPaths: AssetPaths | undefined;
+  port: number;
+  ip: string;
+  localProtocol: "https" | "http";
+  inspectorPort: number;
+  accountId: string | undefined;
+  apiToken: string | undefined;
+  bindings: CfWorkerInit["bindings"];
+  compatibilityDate: string;
+  compatibilityFlags: string[] | undefined;
+  usageModel: "bundled" | "unbound" | undefined;
+  env: string | undefined;
+  legacyEnv: boolean | undefined;
+  zone: { id: string; host: string } | undefined;
+}) {
+  assert(props.accountId, "accountId is required");
+  assert(props.apiToken, "apiToken is required");
+  const previewToken = useWorker({
+    name: props.name,
+    bundle: props.bundle,
+    format: props.format,
+    modules: props.bundle ? props.bundle.modules : [],
+    accountId: props.accountId,
+    apiToken: props.apiToken,
+    bindings: props.bindings,
+    assetPaths: props.assetPaths,
+    port: props.port,
+    compatibilityDate: props.compatibilityDate,
+    compatibilityFlags: props.compatibilityFlags,
+    usageModel: props.usageModel,
+    env: props.env,
+    legacyEnv: props.legacyEnv,
+    zone: props.zone,
+  });
+
+  usePreviewServer({
+    previewToken,
+    publicRoot: props.public,
+    localProtocol: props.localProtocol,
+    localPort: props.port,
+    ip: props.ip,
+  });
+
+  useInspector({
+    inspectorUrl: previewToken ? previewToken.inspectorUrl.href : undefined,
+    port: props.inspectorPort,
+    logToTerminal: true,
+  });
+  return null;
+}
+
+export function useWorker(props: {
+  name: string | undefined;
+  bundle: EsbuildBundle | undefined;
+  format: CfScriptFormat | undefined;
+  modules: CfModule[];
+  accountId: string;
+  apiToken: string;
+  bindings: CfWorkerInit["bindings"];
+  assetPaths: AssetPaths | undefined;
+  port: number;
+  compatibilityDate: string | undefined;
+  compatibilityFlags: string[] | undefined;
+  usageModel: "bundled" | "unbound" | undefined;
+  env: string | undefined;
+  legacyEnv: boolean | undefined;
+  zone: { id: string; host: string } | undefined;
+}): CfPreviewToken | undefined {
+  const {
+    name,
+    bundle,
+    format,
+    modules,
+    accountId,
+    apiToken,
+    bindings,
+    assetPaths,
+    compatibilityDate,
+    compatibilityFlags,
+    usageModel,
+    port,
+  } = props;
+  const [token, setToken] = useState<CfPreviewToken | undefined>();
+
+  // This is the most reliable way to detect whether
+  // something's "happened" in our system; We make a ref and
+  // mark it once we log our initial message. Refs are vars!
+  const startedRef = useRef(false);
+
+  useEffect(() => {
+    const abortController = new AbortController();
+    async function start() {
+      setToken(undefined); // reset token in case we're re-running
+
+      if (!bundle || !format) return;
+
+      if (!startedRef.current) {
+        startedRef.current = true;
+      } else {
+        logger.log("⎔ Detected changes, restarted server.");
+      }
+
+      const assets = await syncAssets(
+        accountId,
+        // When we're using the newer service environments, we wouldn't
+        // have added the env name on to the script name. However, we must
+        // include it in the kv namespace name regardless (since there's no
+        // concept of service environments for kv namespaces yet).
+        name + (!props.legacyEnv && props.env ? `-${props.env}` : ""),
+        assetPaths,
+        true,
+        false
+      ); // TODO: cancellable?
+
+      const content = await readFile(bundle.path, "utf-8");
+
+      const init: CfWorkerInit = {
+        name,
+        main: {
+          name: path.basename(bundle.path),
+          type: format === "modules" ? "esm" : "commonjs",
+          content,
+        },
+        modules: modules.concat(
+          assets.manifest
+            ? {
+                name: "__STATIC_CONTENT_MANIFEST",
+                content: JSON.stringify(assets.manifest),
+                type: "text",
+              }
+            : []
+        ),
+        bindings: {
+          ...bindings,
+          kv_namespaces: (bindings.kv_namespaces || []).concat(
+            assets.namespace
+              ? { binding: "__STATIC_CONTENT", id: assets.namespace }
+              : []
+          ),
+          text_blobs: {
+            ...bindings.text_blobs,
+            ...(assets.manifest &&
+              format === "service-worker" && {
+                __STATIC_CONTENT_MANIFEST: "__STATIC_CONTENT_MANIFEST",
+              }),
+          },
+        },
+        migrations: undefined, // no migrations in dev
+        compatibility_date: compatibilityDate,
+        compatibility_flags: compatibilityFlags,
+        usage_model: usageModel,
+      };
+      setToken(
+        await createWorkerPreview(
+          init,
+          {
+            accountId,
+            apiToken,
+          },
+          { env: props.env, legacyEnv: props.legacyEnv, zone: props.zone },
+          abortController.signal
+        )
+      );
+    }
+    start().catch((err) => {
+      // we want to log the error, but not end the process
+      // since it could recover after the developer fixes whatever's wrong
+      if ((err as { code: string }).code !== "ABORT_ERR") {
+        logger.error("Error on remote worker:", err);
+      }
+    });
+
+    return () => {
+      abortController.abort();
+    };
+  }, [
+    name,
+    bundle,
+    format,
+    accountId,
+    apiToken,
+    port,
+    assetPaths,
+    compatibilityDate,
+    compatibilityFlags,
+    usageModel,
+    bindings,
+    modules,
+    props.env,
+    props.legacyEnv,
+    props.zone,
+  ]);
+  return token;
+}

package/src/dev/use-esbuild.ts

@@ -0,0 +1,118 @@
+import assert from "node:assert";
+import { useApp } from "ink";
+import { useState, useEffect } from "react";
+import { bundleWorker } from "../bundle";
+import { logger } from "../logger";
+import type { Config } from "../config";
+import type { Entry } from "../entry";
+import type { CfModule } from "../worker";
+import type { WatchMode } from "esbuild";
+
+export type EsbuildBundle = {
+  id: number;
+  path: string;
+  entry: Entry;
+  type: "esm" | "commonjs";
+  modules: CfModule[];
+  serveAssetsFromWorker: boolean;
+};
+
+export function useEsbuild({
+  entry,
+  destination,
+  staticRoot,
+  jsxFactory,
+  jsxFragment,
+  rules,
+  serveAssetsFromWorker,
+  tsconfig,
+  minify,
+  nodeCompat,
+}: {
+  entry: Entry;
+  destination: string | undefined;
+  staticRoot: string | undefined;
+  jsxFactory: string | undefined;
+  jsxFragment: string | undefined;
+  rules: Config["rules"];
+  serveAssetsFromWorker: boolean;
+  tsconfig: string | undefined;
+  minify: boolean | undefined;
+  nodeCompat: boolean | undefined;
+}): EsbuildBundle | undefined {
+  const [bundle, setBundle] = useState<EsbuildBundle>();
+  const { exit } = useApp();
+  useEffect(() => {
+    let stopWatching: (() => void) | undefined = undefined;
+
+    const watchMode: WatchMode = {
+      async onRebuild(error) {
+        if (error) logger.error("Watch build failed:", error);
+        else {
+          // nothing really changes here, so let's increment the id
+          // to change the return object's identity
+          setBundle((previousBundle) => {
+            assert(
+              previousBundle,
+              "Rebuild triggered with no previous build available"
+            );
+            return { ...previousBundle, id: previousBundle.id + 1 };
+          });
+        }
+      },
+    };
+
+    async function build() {
+      if (!destination) return;
+
+      const { resolvedEntryPointPath, bundleType, modules, stop } =
+        await bundleWorker(entry, destination, {
+          // In dev, we serve assets from the local proxy before we send the request to the worker.
+          serveAssetsFromWorker: false,
+          jsxFactory,
+          jsxFragment,
+          rules,
+          watch: watchMode,
+          tsconfig,
+          minify,
+          nodeCompat,
+        });
+
+      // Capture the `stop()` method to use as the `useEffect()` destructor.
+      stopWatching = stop;
+
+      setBundle({
+        id: 0,
+        entry,
+        path: resolvedEntryPointPath,
+        type: bundleType,
+        modules,
+        serveAssetsFromWorker,
+      });
+    }
+
+    build().catch((err) => {
+      // If esbuild fails on first run, we want to quit the process
+      // since we can't recover from here
+      // related: https://github.com/evanw/esbuild/issues/1037
+      exit(err);
+    });
+
+    return () => {
+      stopWatching?.();
+    };
+  }, [
+    entry,
+    destination,
+    staticRoot,
+    jsxFactory,
+    jsxFragment,
+    serveAssetsFromWorker,
+    rules,
+    tsconfig,
+    exit,
+    minify,
+    nodeCompat,
+  ]);
+  return bundle;
+}