miniflare 0.0.0-e4fe35cc5 → 0.0.0-eaf71b86c

package/dist/src/index.js

@@ -2547,7 +2547,7 @@ __export(src_exports, {
   _transformsForContentEncodingAndContentType: () => _transformsForContentEncodingAndContentType,
   base64Decode: () => base64Decode,
   base64Encode: () => base64Encode,
-  buildAssetsManifest: () => buildAssetsManifest,
+  buildAssetManifest: () => buildAssetManifest,
   compileModuleRules: () => compileModuleRules,
   coupleWebSocket: () => coupleWebSocket,
   createFetchMock: () => createFetchMock,
@@ -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";
@@ -4945,6 +4949,12 @@ var Runtime = class {
   }
 };
 
+// src/plugins/assets/constants.ts
+var ASSETS_PLUGIN_NAME = "assets";
+var ASSETS_SERVICE_NAME = `${ASSETS_PLUGIN_NAME}:assets-service`;
+var ROUTER_SERVICE_NAME = `${ASSETS_PLUGIN_NAME}:router`;
+var ASSETS_KV_SERVICE_NAME = `${ASSETS_PLUGIN_NAME}:kv`;
+
 // src/plugins/cache/index.ts
 var import_promises4 = __toESM(require("fs/promises"));
 
@@ -5482,6 +5492,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 +5644,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 +5739,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) {
@@ -6866,7 +6931,11 @@ var CoreOptionsSchemaInput = import_zod12.z.intersection(
     unsafeEphemeralDurableObjects: import_zod12.z.boolean().optional(),
     unsafeDirectSockets: UnsafeDirectSocketSchema.array().optional(),
     unsafeEvalBinding: import_zod12.z.string().optional(),
-    unsafeUseModuleFallbackService: import_zod12.z.boolean().optional()
+    unsafeUseModuleFallbackService: import_zod12.z.boolean().optional(),
+    /** Used to set the vitest pool worker SELF binding to point to the router worker if there are assets.
+     (If there are assets but we're not using vitest, the miniflare entry worker can point directly to RW.)
+     */
+    hasAssetsAndIsVitest: import_zod12.z.boolean().optional()
   })
 );
 var CoreOptionsSchema = CoreOptionsSchemaInput.transform((value) => {
@@ -6931,7 +7000,7 @@ var SCRIPT_CUSTOM_SERVICE = `addEventListener("fetch", (event) => {
   request.headers.set("${CoreHeaders.ORIGINAL_URL}", request.url);
   event.respondWith(${CoreBindings.SERVICE_LOOPBACK}.fetch(request));
 })`;
-function getCustomServiceDesignator(refererName, workerIndex, kind, name, service) {
+function getCustomServiceDesignator(refererName, workerIndex, kind, name, service, hasAssetsAndIsVitest = false) {
   let serviceName;
   let entrypoint;
   if (typeof service === "function") {
@@ -6948,7 +7017,7 @@ function getCustomServiceDesignator(refererName, workerIndex, kind, name, servic
       serviceName = getBuiltinServiceName(workerIndex, kind, name);
     }
   } else if (service === kCurrentWorker) {
-    serviceName = getUserServiceName(refererName);
+    serviceName = hasAssetsAndIsVitest ? ROUTER_SERVICE_NAME : getUserServiceName(refererName);
   } else {
     serviceName = getUserServiceName(service);
   }
@@ -7059,7 +7128,8 @@ var CORE_PLUGIN = {
               workerIndex,
               "#" /* UNKNOWN */,
               name,
-              service
+              service,
+              options.hasAssetsAndIsVitest
             )
           };
         })
@@ -7281,7 +7351,8 @@ Ensure ${stringName} doesn't include unbundled \`import\`s.`
             workerIndex,
             "$" /* KNOWN */,
             CUSTOM_SERVICE_KNOWN_OUTBOUND,
-            options.outboundService
+            options.outboundService,
+            options.hasAssetsAndIsVitest
           ),
           cacheApiOutbound: { name: getCacheServiceName(workerIndex) },
           moduleFallback: options.unsafeUseModuleFallbackService && sharedOptions.unsafeModuleFallbackService !== void 0 ? `localhost:${loopbackPort}` : void 0
@@ -7444,6 +7515,7 @@ function getWorkerScript(options, workerIndex, additionalModuleNames) {
       modulesRoot,
       additionalModuleNames,
       options.modulesRules,
+      options.compatibilityDate,
       options.compatibilityFlags
     );
     locator.visitEntrypoint(code, scriptPath);
@@ -7454,21 +7526,17 @@ function getWorkerScript(options, workerIndex, additionalModuleNames) {
   }
 }
 
-// src/plugins/assets/constants.ts
-var ASSETS_PLUGIN_NAME = "assets";
-var ASSETS_SERVICE_NAME = `${ASSETS_PLUGIN_NAME}:assets-service`;
-var ROUTER_SERVICE_NAME = `${ASSETS_PLUGIN_NAME}:router`;
-var ASSETS_KV_SERVICE_NAME = `${ASSETS_PLUGIN_NAME}:kv`;
-
 // src/plugins/assets/schema.ts
 var import_zod13 = require("zod");
 var AssetsOptionsSchema = import_zod13.z.object({
   assets: import_zod13.z.object({
+    // User worker name or vitest runner - this is only ever set inside miniflare
+    // The assets plugin needs access to the worker name to create the router worker - user worker binding
     workerName: import_zod13.z.string().optional(),
-    path: PathSchema,
-    bindingName: import_zod13.z.string().optional(),
-    routingConfig: RoutingConfigSchema,
-    assetConfig: AssetConfigSchema
+    directory: PathSchema,
+    binding: import_zod13.z.string().optional(),
+    routingConfig: RoutingConfigSchema.optional(),
+    assetConfig: AssetConfigSchema.optional()
   }).optional()
 });
 
@@ -7476,35 +7544,37 @@ var AssetsOptionsSchema = import_zod13.z.object({
 var ASSETS_PLUGIN = {
   options: AssetsOptionsSchema,
   async getBindings(options) {
-    if (!options.assets?.bindingName) {
+    if (!options.assets?.binding) {
       return [];
     }
     return [
       {
         // binding between User Worker and Asset Worker
-        name: options.assets.bindingName,
+        name: options.assets.binding,
         service: { name: ASSETS_SERVICE_NAME }
       }
     ];
   },
   async getNodeBindings(options) {
-    if (!options.assets?.bindingName) {
+    if (!options.assets?.binding) {
       return {};
     }
     return {
-      [options.assets.bindingName]: new ProxyNodeBinding()
+      [options.assets.binding]: new ProxyNodeBinding()
     };
   },
   async getServices({ options }) {
     if (!options.assets) {
       return [];
     }
-    const assetsReverseMap = await createReverseMap(options.assets?.path);
     const storageServiceName = `${ASSETS_PLUGIN_NAME}:storage`;
     const storageService = {
       name: storageServiceName,
-      disk: { path: options.assets.path, writable: true }
+      disk: { path: options.assets.directory, writable: true }
     };
+    const { encodedAssetManifest, assetsReverseMap } = await buildAssetManifest(
+      options.assets.directory
+    );
     const namespaceService = {
       name: ASSETS_KV_SERVICE_NAME,
       worker: {
@@ -7523,12 +7593,11 @@ var ASSETS_PLUGIN = {
           },
           {
             name: "ASSETS_REVERSE_MAP",
-            json: assetsReverseMap
+            json: JSON.stringify(assetsReverseMap)
           }
         ]
       }
     };
-    const assetsManifest = await buildAssetsManifest(options.assets.path);
     const assetService = {
       name: ASSETS_SERVICE_NAME,
       worker: {
@@ -7546,11 +7615,11 @@ var ASSETS_PLUGIN = {
           },
           {
             name: "ASSETS_MANIFEST",
-            data: assetsManifest
+            data: encodedAssetManifest
           },
           {
             name: "CONFIG",
-            json: JSON.stringify(options.assets.assetConfig)
+            json: JSON.stringify(options.assets.assetConfig ?? {})
           }
         ]
       }
@@ -7584,20 +7653,21 @@ var ASSETS_PLUGIN = {
     return [storageService, namespaceService, assetService, routerService];
   }
 };
-var buildAssetsManifest = async (dir) => {
-  const manifest = await walk(dir);
+var buildAssetManifest = async (dir) => {
+  const { manifest, assetsReverseMap } = await walk(dir);
   const sortedAssetManifest = sortManifest(manifest);
   const encodedAssetManifest = encodeManifest(sortedAssetManifest);
-  return encodedAssetManifest;
+  return { encodedAssetManifest, assetsReverseMap };
 };
 var walk = async (dir) => {
   const files = await import_promises7.default.readdir(dir, { recursive: true });
   const manifest = [];
+  const assetsReverseMap = {};
   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;
@@ -7619,9 +7689,19 @@ Cloudflare Workers supports assets with sizes of up to ${prettyBytes(
 Ensure all assets in your assets directory "${dir}" conform with the Workers maximum size requirement.`
           );
         }
-        manifest.push(
-          await hashPath(encodeFilePath(relativeFilepath, import_node_path.default.sep))
-        );
+        const [pathHash, contentHash] = await Promise.all([
+          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,
+          contentHash
+        });
+        assetsReverseMap[bytesToHex(contentHash)] = {
+          filePath: relativeFilepath,
+          contentType: getContentType(filepath)
+        };
         counter++;
       }
     })
@@ -7633,23 +7713,23 @@ Cloudflare Workers supports up to ${MAX_ASSET_COUNT.toLocaleString()} assets in
 Ensure your assets directory contains a maximum of ${MAX_ASSET_COUNT.toLocaleString()} files, and that you have specified your assets directory correctly.`
     );
   }
-  return manifest;
+  return { manifest, assetsReverseMap };
 };
 var sortManifest = (manifest) => {
   return manifest.sort(comparisonFn);
 };
 var comparisonFn = (a, b) => {
-  if (a.length < b.length) {
+  if (a.pathHash.length < b.pathHash.length) {
     return -1;
   }
-  if (a.length > b.length) {
+  if (a.pathHash.length > b.pathHash.length) {
     return 1;
   }
-  for (const [i, v] of a.entries()) {
-    if (v < b[i]) {
+  for (const [i, v] of a.pathHash.entries()) {
+    if (v < b.pathHash[i]) {
       return -1;
     }
-    if (v > b[i]) {
+    if (v > b.pathHash[i]) {
       return 1;
     }
   }
@@ -7661,34 +7741,14 @@ var encodeManifest = (manifest) => {
   );
   for (const [i, entry] of manifest.entries()) {
     const entryOffset = HEADER_SIZE + i * ENTRY_SIZE;
-    assetManifestBytes.set(entry, entryOffset + PATH_HASH_OFFSET);
-    assetManifestBytes.set(entry, entryOffset + CONTENT_HASH_OFFSET);
+    assetManifestBytes.set(entry.pathHash, entryOffset + PATH_HASH_OFFSET);
+    assetManifestBytes.set(
+      entry.contentHash,
+      entryOffset + CONTENT_HASH_OFFSET
+    );
   }
   return assetManifestBytes;
 };
-var createReverseMap = async (dir) => {
-  const files = await import_promises7.default.readdir(dir, { recursive: true });
-  const assetsReverseMap = {};
-  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 filestat = await import_promises7.default.stat(filepath);
-      if (filestat.isSymbolicLink() || filestat.isDirectory()) {
-        return;
-      } else {
-        const pathHash = bytesToHex(
-          await hashPath(encodeFilePath(relativeFilepath, import_node_path.default.sep))
-        );
-        assetsReverseMap[pathHash] = {
-          filePath: relativeFilepath,
-          contentType: getContentType(filepath)
-        };
-      }
-    })
-  );
-  return JSON.stringify(assetsReverseMap);
-};
 var bytesToHex = (buffer) => {
   return [...new Uint8Array(buffer)].map((b) => b.toString(16).padStart(2, "0")).join("");
 };
@@ -9084,8 +9144,15 @@ function getQueueProducers(allWorkerOpts) {
           ])
         );
       }
-      for (const [bindingName, opts] of Object.entries(workerProducers)) {
-        queueProducers.set(bindingName, { workerName, ...opts });
+      const producersIterable = Object.entries(
+        workerProducers
+      );
+      for (const [bindingName, opts] of producersIterable) {
+        if (typeof opts === "string") {
+          queueProducers.set(bindingName, { workerName, queueName: opts });
+        } else {
+          queueProducers.set(bindingName, { workerName, ...opts });
+        }
       }
     }
   }
@@ -9568,6 +9635,9 @@ var Miniflare2 = class {
     const proxyBindings = [];
     const allWorkerBindings = /* @__PURE__ */ new Map();
     const wrappedBindingsToPopulate = [];
+    if (this.#workerOpts[0].assets.assets) {
+      this.#workerOpts[0].assets.assets.workerName = this.#workerOpts[0].core.name;
+    }
     for (let i = 0; i < allWorkerOpts.length; i++) {
       const previousWorkerOpts = allPreviousWorkerOpts?.[i];
       const workerOpts = allWorkerOpts[i];
@@ -9687,8 +9757,11 @@ var Miniflare2 = class {
     const globalServices = getGlobalServices({
       sharedOptions: sharedOpts.core,
       allWorkerRoutes,
-      // if Workers + Assets project, point to router Worker service rather than user Worker
-      fallbackWorkerName: this.#workerOpts[0].assets.assets ? ROUTER_SERVICE_NAME : getUserServiceName(this.#workerOpts[0].core.name),
+      // if Workers + Assets project but NOT Vitest, point to router Worker instead
+      // if Vitest with assets, the self binding on the test runner will point to RW
+      fallbackWorkerName: this.#workerOpts[0].assets.assets && !this.#workerOpts[0].core.name?.startsWith(
+        "vitest-pool-workers-runner-"
+      ) ? ROUTER_SERVICE_NAME : getUserServiceName(this.#workerOpts[0].core.name),
       loopbackPort,
       log: this.#log,
       proxyBindings
@@ -10195,7 +10268,7 @@ var Miniflare2 = class {
   _transformsForContentEncodingAndContentType,
   base64Decode,
   base64Encode,
-  buildAssetsManifest,
+  buildAssetManifest,
   compileModuleRules,
   coupleWebSocket,
   createFetchMock,
@@ -10215,6 +10288,7 @@ var Miniflare2 = class {
   getFreshSourceMapSupport,
   getGlobalServices,
   getMiniflareObjectBindings,
+  getNodeCompat,
   getPersistPath,
   getRootPath,
   globsToRegExps,