miniflare 0.0.0-a602de088 → 0.0.0-a67cdbfc4

package/dist/src/index.d.ts

@@ -1494,6 +1494,30 @@ export declare function getGlobalServices({ sharedOptions, allWorkerRoutes, fall
 
 export declare function getMiniflareObjectBindings(unsafeStickyBlobs: boolean): Worker_Binding[];
 
+/**
+ * Computes the Node.js compatibility mode we are running.
+ *
+ * NOTES:
+ * - The v2 mode is configured via `nodejs_compat_v2` compat flag or via `nodejs_compat` plus a compatibility date of Sept 23rd. 2024 or later.
+ * - See `EnvironmentInheritable` for `nodeCompat` and `noBundle`.
+ *
+ * @param compatibilityDateStr The compatibility date
+ * @param compatibilityFlags The compatibility flags
+ * @param opts.nodeCompat Whether the legacy node_compat arg is being used
+ * @returns the mode and flags to indicate specific configuration for validating.
+ */
+export declare function getNodeCompat(compatibilityDate: string | undefined, // Default to some arbitrary old date
+compatibilityFlags: string[], opts?: {
+    nodeCompat?: boolean;
+}): {
+    mode: NodeJSCompatMode;
+    hasNodejsAlsFlag: boolean;
+    hasNodejsCompatFlag: boolean;
+    hasNodejsCompatV2Flag: boolean;
+    hasNoNodejsCompatV2Flag: boolean;
+    hasExperimentalNodejsCompatV2Flag: boolean;
+};
+
 export declare function getPersistPath(pluginName: string, tmpPath: string, persist: Persistence): string;
 
 export declare function getRootPath(opts: unknown): string;
@@ -1821,6 +1845,17 @@ export declare interface Network {
 
 export declare const NODE_PLATFORM_IMPL: PlatformImpl<ReadableStream_2>;
 
+/**
+ * We can provide Node.js compatibility in a number of different modes:
+ * - "legacy" - this mode adds compile-time polyfills that are not well maintained and cannot work with workerd runtime builtins.
+ * - "als": this mode tells the workerd runtime to enable only the Async Local Storage builtin library (accessible via `node:async_hooks`).
+ * - "v1" - this mode tells the workerd runtime to enable some Node.js builtin libraries (accessible only via `node:...` imports) but no globals.
+ * - "v2" - this mode tells the workerd runtime to enable more Node.js builtin libraries (accessible both with and without the `node:` prefix)
+ *   and also some Node.js globals such as `Buffer`; it also turns on additional compile-time polyfills for those that are not provided by the runtime.
+ *  - null - no Node.js compatibility.
+ */
+export declare type NodeJSCompatMode = "legacy" | "als" | "v1" | "v2" | null;
+
 export declare class NoOpLog extends Log {
     constructor();
     protected log(): void;

package/dist/src/index.js

@@ -2567,6 +2567,7 @@ __export(src_exports, {
   getFreshSourceMapSupport: () => getFreshSourceMapSupport,
   getGlobalServices: () => getGlobalServices,
   getMiniflareObjectBindings: () => getMiniflareObjectBindings,
+  getNodeCompat: () => getNodeCompat,
   getPersistPath: () => getPersistPath,
   getRootPath: () => getRootPath,
   globsToRegExps: () => globsToRegExps,
@@ -4587,7 +4588,7 @@ var import_undici4 = require("undici");
 // src/plugins/assets/index.ts
 var import_node_crypto = __toESM(require("node:crypto"));
 var import_promises7 = __toESM(require("node:fs/promises"));
-var import_node_path = __toESM(require("node:path"));
+var import_node_path2 = __toESM(require("node:path"));
 
 // ../workers-shared/utils/constants.ts
 var HEADER_SIZE = 20;
@@ -4616,10 +4617,13 @@ var AssetConfigSchema = import_zod4.z.object({
 });
 
 // ../workers-shared/utils/helpers.ts
+var import_node_path = require("node:path");
 var import_mime = __toESM(require_mime());
-var encodeFilePath = (filePath, sep) => {
-  const encodedPath = filePath.split(sep).map((segment) => encodeURIComponent(segment)).join("/");
-  return "/" + encodedPath;
+var normalizeFilePath = (relativeFilepath) => {
+  if ((0, import_node_path.isAbsolute)(relativeFilepath)) {
+    throw new Error(`Expected relative path`);
+  }
+  return "/" + relativeFilepath.split(import_node_path.sep).join("/");
 };
 var getContentType = (absFilePath) => {
   let contentType = (0, import_mime.getType)(absFilePath) || "application/octet-stream";
@@ -5482,6 +5486,51 @@ var import_util = require("util");
 var import_acorn = require("acorn");
 var import_acorn_walk = require("acorn-walk");
 var import_zod9 = require("zod");
+
+// src/plugins/core/node-compat.ts
+function getNodeCompat(compatibilityDate = "2000-01-01", compatibilityFlags, opts) {
+  const { nodeCompat = false } = opts ?? {};
+  const {
+    hasNodejsAlsFlag,
+    hasNodejsCompatFlag,
+    hasNodejsCompatV2Flag,
+    hasNoNodejsCompatV2Flag,
+    hasExperimentalNodejsCompatV2Flag
+  } = parseNodeCompatibilityFlags(compatibilityFlags);
+  const nodeCompatSwitchOverDate = "2024-09-23";
+  const legacy = nodeCompat === true;
+  let mode = null;
+  if (hasNodejsCompatV2Flag || hasNodejsCompatFlag && compatibilityDate >= nodeCompatSwitchOverDate && !hasNoNodejsCompatV2Flag) {
+    mode = "v2";
+  } else if (hasNodejsCompatFlag) {
+    mode = "v1";
+  } else if (hasNodejsAlsFlag) {
+    mode = "als";
+  } else if (legacy) {
+    mode = "legacy";
+  }
+  return {
+    mode,
+    hasNodejsAlsFlag,
+    hasNodejsCompatFlag,
+    hasNodejsCompatV2Flag,
+    hasNoNodejsCompatV2Flag,
+    hasExperimentalNodejsCompatV2Flag
+  };
+}
+function parseNodeCompatibilityFlags(compatibilityFlags) {
+  return {
+    hasNodejsAlsFlag: compatibilityFlags.includes("nodejs_als"),
+    hasNodejsCompatFlag: compatibilityFlags.includes("nodejs_compat"),
+    hasNodejsCompatV2Flag: compatibilityFlags.includes("nodejs_compat_v2"),
+    hasNoNodejsCompatV2Flag: compatibilityFlags.includes("no_nodejs_compat_v2"),
+    hasExperimentalNodejsCompatV2Flag: compatibilityFlags.includes(
+      "experimental:nodejs_compat_v2"
+    )
+  };
+}
+
+// src/plugins/core/modules.ts
 var SUGGEST_BUNDLE = "If you're trying to import an npm package, you'll need to bundle your Worker first.";
 var SUGGEST_NODE = "If you're trying to import a Node.js built-in module, or an npm package that uses Node.js built-ins, you'll either need to:\n- Bundle your Worker, configuring your bundler to polyfill Node.js built-ins\n- Configure your bundler to load Workers-compatible builds by changing the main fields/conditions\n- Enable the `nodejs_compat` compatibility flag and use the `NodeJsCompatModule` module type\n- Find an alternative package that doesn't require Node.js built-ins";
 var builtinModulesWithPrefix = import_module.builtinModules.concat(
@@ -5589,15 +5638,18 @@ function getResolveErrorPrefix(referencingPath) {
   return `Unable to resolve "${relative}" dependency`;
 }
 var ModuleLocator = class {
-  constructor(modulesRoot, additionalModuleNames, rules = [], compatibilityFlags) {
+  constructor(modulesRoot, additionalModuleNames, rules = [], compatibilityDate, compatibilityFlags) {
     this.modulesRoot = modulesRoot;
     this.additionalModuleNames = additionalModuleNames;
     rules = rules.concat(DEFAULT_MODULE_RULES);
     this.#compiledRules = compileModuleRules(rules);
-    this.#nodejsCompat = compatibilityFlags?.includes("nodejs_compat") ?? false;
+    this.#nodejsCompatMode = getNodeCompat(
+      compatibilityDate,
+      compatibilityFlags ?? []
+    ).mode;
   }
   #compiledRules;
-  #nodejsCompat;
+  #nodejsCompatMode;
   #visitedPaths = /* @__PURE__ */ new Set();
   modules = [];
   visitEntrypoint(code, modulePath) {
@@ -5681,7 +5733,14 @@ ${dim(modulesConfig)}`;
     }
     const spec = specExpression.value;
     const isNodeJsCompatModule = referencingType === "NodeJsCompatModule";
-    if (this.#nodejsCompat && spec.startsWith("node:") || spec.startsWith("cloudflare:") || spec.startsWith("workerd:") || isNodeJsCompatModule && builtinModulesWithPrefix.includes(spec) || this.additionalModuleNames.includes(spec)) {
+    if (
+      // `cloudflare:` and `workerd:` imports don't need to be included explicitly
+      spec.startsWith("cloudflare:") || spec.startsWith("workerd:") || // Node.js compat v1 requires imports to be prefixed with `node:`
+      this.#nodejsCompatMode === "v1" && spec.startsWith("node:") || // Node.js compat modules and v2 can also handle non-prefixed imports
+      (this.#nodejsCompatMode === "v2" || isNodeJsCompatModule) && builtinModulesWithPrefix.includes(spec) || // Async Local Storage mode (node_als) only deals with `node:async_hooks` imports
+      this.#nodejsCompatMode === "als" && spec === "node:async_hooks" || // Any "additional" external modules can be ignored
+      this.additionalModuleNames.includes(spec)
+    ) {
       return;
     }
     if (maybeGetStringScriptPathIndex(referencingName) !== void 0) {
@@ -7444,6 +7503,7 @@ function getWorkerScript(options, workerIndex, additionalModuleNames) {
       modulesRoot,
       additionalModuleNames,
       options.modulesRules,
+      options.compatibilityDate,
       options.compatibilityFlags
     );
     locator.visitEntrypoint(code, scriptPath);
@@ -7598,8 +7658,8 @@ var walk = async (dir) => {
   let counter = 0;
   await Promise.all(
     files.map(async (file) => {
-      const filepath = import_node_path.default.join(dir, file);
-      const relativeFilepath = import_node_path.default.relative(dir, filepath);
+      const filepath = import_node_path2.default.join(dir, file);
+      const relativeFilepath = import_node_path2.default.relative(dir, filepath);
       const filestat = await import_promises7.default.stat(filepath);
       if (filestat.isSymbolicLink() || filestat.isDirectory()) {
         return;
@@ -7622,10 +7682,9 @@ Ensure all assets in your assets directory "${dir}" conform with the Workers max
           );
         }
         const [pathHash, contentHash] = await Promise.all([
-          hashPath(encodeFilePath(relativeFilepath, import_node_path.default.sep)),
-          hashPath(
-            encodeFilePath(filepath, import_node_path.default.sep) + filestat.mtimeMs.toString()
-          )
+          hashPath(normalizeFilePath(relativeFilepath)),
+          // used absolute filepath here so that changes to the enclosing asset folder will be registered
+          hashPath(filepath + filestat.mtimeMs.toString())
         ]);
         manifest.push({
           pathHash,
@@ -10215,6 +10274,7 @@ var Miniflare2 = class {
   getFreshSourceMapSupport,
   getGlobalServices,
   getMiniflareObjectBindings,
+  getNodeCompat,
   getPersistPath,
   getRootPath,
   globsToRegExps,