miniflare 0.0.0-48eeff467 → 0.0.0-4e33f2cdc

package/dist/src/index.d.ts

@@ -58,6 +58,13 @@ export declare class __MiniflareFunctionWrapper {
 
 export declare type AnyHeaders = http.IncomingHttpHeaders | string[];
 
+export declare type AssetReverseMap = {
+    [pathHash: string]: {
+        filePath: string;
+        contentType: string;
+    };
+};
+
 export declare const ASSETS_PLUGIN: Plugin<typeof AssetsOptionsSchema>;
 
 export declare const AssetsOptionsSchema: z.ZodObject<{
@@ -141,7 +148,19 @@ export declare function base64Encode(value: string): string;
 
 export { BodyInit }
 
-export declare const buildAssetsManifest: (dir: string) => Promise<Uint8Array>;
+/**
+ * The Asset Manifest and Asset Reverse Map are used to map a request path to an asset.
+ * 1. Hash path of request
+ * 2. Use this path hash to find the manifest entry
+ * 3. Get content hash from manifest entry
+ * 4a. In prod, use content hash to get asset from KV
+ * 4b. In dev, we fake out the KV store and use the file system instead.
+ * 	   Use content hash to get file path from asset reverse map.
+ */
+export declare const buildAssetManifest: (dir: string) => Promise<{
+    encodedAssetManifest: Uint8Array;
+    assetsReverseMap: AssetReverseMap;
+}>;
 
 export declare const CACHE_PLUGIN: Plugin<typeof CacheOptionsSchema, typeof CacheSharedOptionsSchema>;
 
@@ -1347,6 +1366,7 @@ export declare const DURABLE_OBJECTS_PLUGIN_NAME = "do";
 export declare const DURABLE_OBJECTS_STORAGE_SERVICE_NAME = "do:storage";
 
 export declare type DurableObjectClassNames = Map<string, Map<string, {
+    enableSql?: boolean;
     unsafeUniqueKey?: UnsafeUniqueKey;
     unsafePreventEviction?: boolean;
 }>>;
@@ -1355,16 +1375,19 @@ export declare const DurableObjectsOptionsSchema: z.ZodObject<{
     durableObjects: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodObject<{
         className: z.ZodString;
         scriptName: z.ZodOptional<z.ZodString>;
+        useSQLite: z.ZodOptional<z.ZodBoolean>;
         unsafeUniqueKey: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodLiteral<typeof kUnsafeEphemeralUniqueKey>]>>;
         unsafePreventEviction: z.ZodOptional<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
         className: string;
         scriptName?: string | undefined;
+        useSQLite?: boolean | undefined;
         unsafeUniqueKey?: string | typeof kUnsafeEphemeralUniqueKey | undefined;
         unsafePreventEviction?: boolean | undefined;
     }, {
         className: string;
         scriptName?: string | undefined;
+        useSQLite?: boolean | undefined;
         unsafeUniqueKey?: string | typeof kUnsafeEphemeralUniqueKey | undefined;
         unsafePreventEviction?: boolean | undefined;
     }>]>>>;
@@ -1372,6 +1395,7 @@ export declare const DurableObjectsOptionsSchema: z.ZodObject<{
     durableObjects?: Record<string, string | {
         className: string;
         scriptName?: string | undefined;
+        useSQLite?: boolean | undefined;
         unsafeUniqueKey?: string | typeof kUnsafeEphemeralUniqueKey | undefined;
         unsafePreventEviction?: boolean | undefined;
     }> | undefined;
@@ -1379,6 +1403,7 @@ export declare const DurableObjectsOptionsSchema: z.ZodObject<{
     durableObjects?: Record<string, string | {
         className: string;
         scriptName?: string | undefined;
+        useSQLite?: boolean | undefined;
         unsafeUniqueKey?: string | typeof kUnsafeEphemeralUniqueKey | undefined;
         unsafePreventEviction?: boolean | undefined;
     }> | undefined;
@@ -1667,6 +1692,11 @@ export declare interface LogOptions {
     suffix?: string;
 }
 
+export declare type ManifestEntry = {
+    pathHash: Uint8Array;
+    contentHash: Uint8Array;
+};
+
 export declare interface MatcherRegExps {
     include: RegExp[];
     exclude: RegExp[];
@@ -1720,7 +1750,7 @@ export declare class Miniflare {
 export declare class MiniflareCoreError extends MiniflareError<MiniflareCoreErrorCode> {
 }
 
-export declare type MiniflareCoreErrorCode = "ERR_RUNTIME_FAILURE" | "ERR_DISPOSED" | "ERR_MODULE_PARSE" | "ERR_MODULE_STRING_SCRIPT" | "ERR_MODULE_DYNAMIC_SPEC" | "ERR_MODULE_RULE" | "ERR_PERSIST_UNSUPPORTED" | "ERR_PERSIST_REMOTE_UNAUTHENTICATED" | "ERR_PERSIST_REMOTE_UNSUPPORTED" | "ERR_FUTURE_COMPATIBILITY_DATE" | "ERR_NO_WORKERS" | "ERR_VALIDATION" | "ERR_DUPLICATE_NAME" | "ERR_DIFFERENT_UNIQUE_KEYS" | "ERR_DIFFERENT_PREVENT_EVICTION" | "ERR_MULTIPLE_OUTBOUNDS" | "ERR_INVALID_WRAPPED" | "ERR_CYCLIC";
+export declare type MiniflareCoreErrorCode = "ERR_RUNTIME_FAILURE" | "ERR_DISPOSED" | "ERR_MODULE_PARSE" | "ERR_MODULE_STRING_SCRIPT" | "ERR_MODULE_DYNAMIC_SPEC" | "ERR_MODULE_RULE" | "ERR_PERSIST_UNSUPPORTED" | "ERR_PERSIST_REMOTE_UNAUTHENTICATED" | "ERR_PERSIST_REMOTE_UNSUPPORTED" | "ERR_FUTURE_COMPATIBILITY_DATE" | "ERR_NO_WORKERS" | "ERR_VALIDATION" | "ERR_DUPLICATE_NAME" | "ERR_DIFFERENT_STORAGE_BACKEND" | "ERR_DIFFERENT_UNIQUE_KEYS" | "ERR_DIFFERENT_PREVENT_EVICTION" | "ERR_MULTIPLE_OUTBOUNDS" | "ERR_INVALID_WRAPPED" | "ERR_CYCLIC";
 
 export declare class MiniflareError<Code extends string | number = string | number> extends Error {
     readonly code: Code;
@@ -1800,6 +1830,7 @@ export declare class NoOpLog extends Log {
 export declare function normaliseDurableObject(designator: NonNullable<z.infer<typeof DurableObjectsOptionsSchema>["durableObjects"]>[string]): {
     className: string;
     serviceName?: string;
+    enableSql?: boolean;
     unsafeUniqueKey?: UnsafeUniqueKey;
     unsafePreventEviction?: boolean;
 };
@@ -2974,16 +3005,19 @@ export declare const PLUGINS: {
     durableObjects: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodObject<{
     className: z.ZodString;
     scriptName: z.ZodOptional<z.ZodString>;
+    useSQLite: z.ZodOptional<z.ZodBoolean>;
     unsafeUniqueKey: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodLiteral<kUnsafeEphemeralUniqueKey>]>>;
     unsafePreventEviction: z.ZodOptional<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
     className: string;
     scriptName?: string | undefined;
+    useSQLite?: boolean | undefined;
     unsafeUniqueKey?: string | kUnsafeEphemeralUniqueKey | undefined;
     unsafePreventEviction?: boolean | undefined;
     }, {
     className: string;
     scriptName?: string | undefined;
+    useSQLite?: boolean | undefined;
     unsafeUniqueKey?: string | kUnsafeEphemeralUniqueKey | undefined;
     unsafePreventEviction?: boolean | undefined;
     }>]>>>;
@@ -2991,6 +3025,7 @@ export declare const PLUGINS: {
     durableObjects?: Record<string, string | {
     className: string;
     scriptName?: string | undefined;
+    useSQLite?: boolean | undefined;
     unsafeUniqueKey?: string | kUnsafeEphemeralUniqueKey | undefined;
     unsafePreventEviction?: boolean | undefined;
     }> | undefined;
@@ -2998,6 +3033,7 @@ export declare const PLUGINS: {
     durableObjects?: Record<string, string | {
     className: string;
     scriptName?: string | undefined;
+    useSQLite?: boolean | undefined;
     unsafeUniqueKey?: string | kUnsafeEphemeralUniqueKey | undefined;
     unsafePreventEviction?: boolean | undefined;
     }> | undefined;
@@ -4174,6 +4210,7 @@ export declare interface Worker_Binding_WrappedBinding {
 export declare type Worker_DurableObjectNamespace = {
     className?: string;
     preventEviction?: boolean;
+    enableSql?: boolean;
 } & ({
     uniqueKey?: string;
 } | {

package/dist/src/index.js

@@ -669,6 +669,24 @@ var require_workerd_capnp = __commonJS({
         capnp_ts_1.Struct.setUint16(0, 8, this);
         capnp_ts_1.Struct.setText(1, value, this);
       }
+      adoptNamedExports(value) {
+        capnp_ts_1.Struct.adopt(value, capnp_ts_1.Struct.getPointer(2, this));
+      }
+      disownNamedExports() {
+        return capnp_ts_1.Struct.disown(this.getNamedExports());
+      }
+      getNamedExports() {
+        return capnp_ts_1.Struct.getList(2, capnp.TextList, this);
+      }
+      hasNamedExports() {
+        return !capnp_ts_1.Struct.isNull(capnp_ts_1.Struct.getPointer(2, this));
+      }
+      initNamedExports(length) {
+        return capnp_ts_1.Struct.initList(2, capnp.TextList, length, this);
+      }
+      setNamedExports(value) {
+        capnp_ts_1.Struct.copyFrom(value, capnp_ts_1.Struct.getPointer(2, this));
+      }
       toString() {
         return "Worker_Module_" + super.toString();
       }
@@ -686,7 +704,7 @@ var require_workerd_capnp = __commonJS({
     Worker_Module3.NODE_JS_COMPAT_MODULE = Worker_Module_Which.NODE_JS_COMPAT_MODULE;
     Worker_Module3.PYTHON_MODULE = Worker_Module_Which.PYTHON_MODULE;
     Worker_Module3.PYTHON_REQUIREMENT = Worker_Module_Which.PYTHON_REQUIREMENT;
-    Worker_Module3._capnp = { displayName: "Module", id: "d9d87a63770a12f3", size: new capnp_ts_1.ObjectSize(8, 2) };
+    Worker_Module3._capnp = { displayName: "Module", id: "d9d87a63770a12f3", size: new capnp_ts_1.ObjectSize(8, 3) };
     var Worker_Binding_Type_Which;
     (function(Worker_Binding_Type_Which2) {
       Worker_Binding_Type_Which2[Worker_Binding_Type_Which2["UNSPECIFIED"] = 0] = "UNSPECIFIED";
@@ -1668,6 +1686,12 @@ var require_workerd_capnp = __commonJS({
       setPreventEviction(value) {
         capnp_ts_1.Struct.setBit(16, value, this);
       }
+      getEnableSql() {
+        return capnp_ts_1.Struct.getBit(17, this);
+      }
+      setEnableSql(value) {
+        capnp_ts_1.Struct.setBit(17, value, this);
+      }
       toString() {
         return "Worker_DurableObjectNamespace_" + super.toString();
       }
@@ -2523,7 +2547,7 @@ __export(src_exports, {
   _transformsForContentEncodingAndContentType: () => _transformsForContentEncodingAndContentType,
   base64Decode: () => base64Decode,
   base64Encode: () => base64Encode,
-  buildAssetsManifest: () => buildAssetsManifest,
+  buildAssetManifest: () => buildAssetManifest,
   compileModuleRules: () => compileModuleRules,
   coupleWebSocket: () => coupleWebSocket,
   createFetchMock: () => createFetchMock,
@@ -4563,7 +4587,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;
@@ -4592,10 +4616,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";
@@ -5337,6 +5364,7 @@ var DurableObjectsOptionsSchema = import_zod8.z.object({
       import_zod8.z.object({
         className: import_zod8.z.string(),
         scriptName: import_zod8.z.string().optional(),
+        useSQLite: import_zod8.z.boolean().optional(),
         // Allow `uniqueKey` to be customised. We use in Wrangler when setting
         // up stub Durable Objects that proxy requests to Durable Objects in
         // another `workerd` process, to ensure the IDs created by the stub
@@ -5355,9 +5383,16 @@ function normaliseDurableObject(designator) {
   const isObject = typeof designator === "object";
   const className = isObject ? designator.className : designator;
   const serviceName = isObject && designator.scriptName !== void 0 ? getUserServiceName(designator.scriptName) : void 0;
+  const enableSql = isObject ? designator.useSQLite : void 0;
   const unsafeUniqueKey = isObject ? designator.unsafeUniqueKey : void 0;
   const unsafePreventEviction = isObject ? designator.unsafePreventEviction : void 0;
-  return { className, serviceName, unsafeUniqueKey, unsafePreventEviction };
+  return {
+    className,
+    serviceName,
+    enableSql,
+    unsafeUniqueKey,
+    unsafePreventEviction
+  };
 }
 var DURABLE_OBJECTS_PLUGIN_NAME = "do";
 var DURABLE_OBJECTS_STORAGE_SERVICE_NAME = `${DURABLE_OBJECTS_PLUGIN_NAME}:storage`;
@@ -7218,16 +7253,21 @@ Ensure ${stringName} doesn't include unbundled \`import\`s.`
           compatibilityFlags: options.compatibilityFlags,
           bindings: workerBindings,
           durableObjectNamespaces: classNamesEntries.map(
-            ([className, { unsafeUniqueKey, unsafePreventEviction }]) => {
+            ([
+              className,
+              { enableSql, unsafeUniqueKey, unsafePreventEviction }
+            ]) => {
               if (unsafeUniqueKey === kUnsafeEphemeralUniqueKey) {
                 return {
                   className,
+                  enableSql,
                   ephemeralLocal: kVoid,
                   preventEviction: unsafePreventEviction
                 };
               } else {
                 return {
                   className,
+                  enableSql,
                   // This `uniqueKey` will (among other things) be used as part of the
                   // path when persisting to the file-system. `-` is invalid in
                   // JavaScript class names, but safe on filesystems (incl. Windows).
@@ -7462,12 +7502,14 @@ var ASSETS_PLUGIN = {
     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 }
     };
+    const { encodedAssetManifest, assetsReverseMap } = await buildAssetManifest(
+      options.assets.path
+    );
     const namespaceService = {
       name: ASSETS_KV_SERVICE_NAME,
       worker: {
@@ -7486,12 +7528,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: {
@@ -7509,7 +7550,7 @@ var ASSETS_PLUGIN = {
           },
           {
             name: "ASSETS_MANIFEST",
-            data: assetsManifest
+            data: encodedAssetManifest
           },
           {
             name: "CONFIG",
@@ -7547,20 +7588,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;
@@ -7582,9 +7624,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++;
       }
     })
@@ -7596,23 +7648,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;
     }
   }
@@ -7624,34 +7676,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("");
 };
@@ -8953,6 +8985,7 @@ function getDurableObjectClassNames(allWorkerOpts) {
         className,
         // Fallback to current worker service if name not defined
         serviceName = workerServiceName,
+        enableSql,
         unsafeUniqueKey,
         unsafePreventEviction
       } = normaliseDurableObject(designator);
@@ -8963,6 +8996,14 @@ function getDurableObjectClassNames(allWorkerOpts) {
       }
       if (classNames.has(className)) {
         const existingInfo = classNames.get(className);
+        if (existingInfo?.enableSql !== enableSql) {
+          throw new MiniflareCoreError(
+            "ERR_DIFFERENT_STORAGE_BACKEND",
+            `Different storage backends defined for Durable Object "${className}" in "${serviceName}": ${JSON.stringify(
+              enableSql
+            )} and ${JSON.stringify(existingInfo?.enableSql)}`
+          );
+        }
         if (existingInfo?.unsafeUniqueKey !== unsafeUniqueKey) {
           throw new MiniflareCoreError(
             "ERR_DIFFERENT_UNIQUE_KEYS",
@@ -8980,7 +9021,11 @@ function getDurableObjectClassNames(allWorkerOpts) {
           );
         }
       } else {
-        classNames.set(className, { unsafeUniqueKey, unsafePreventEviction });
+        classNames.set(className, {
+          enableSql,
+          unsafeUniqueKey,
+          unsafePreventEviction
+        });
       }
     }
   }
@@ -9034,8 +9079,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 });
+        }
       }
     }
   }
@@ -9316,7 +9368,10 @@ var Miniflare2 = class {
     }
     (0, import_assert12.default)(typeof service === "function");
     try {
-      const response = await service(request, this);
+      let response = await service(request, this);
+      if (!(response instanceof Response)) {
+        response = new Response(response.body, response);
+      }
       return import_zod21.z.instanceof(Response).parse(response);
     } catch (e) {
       return new Response(e?.stack ?? e, { status: 500 });
@@ -10142,7 +10197,7 @@ var Miniflare2 = class {
   _transformsForContentEncodingAndContentType,
   base64Decode,
   base64Encode,
-  buildAssetsManifest,
+  buildAssetManifest,
   compileModuleRules,
   coupleWebSocket,
   createFetchMock,