@mainframework/api-request-worker 1.0.3 → 1.0.4

package/dist/workers/api/api.worker.js

@@ -3,23 +3,36 @@ const DEFAULT_FILES_FIELD = "Files";
 const EMPTY_BUFFER = new ArrayBuffer(0);
 const NO_ERROR = { message: "" };
 const DEFAULT_ERROR = "An error occurred";
-const callerResponse = (cacheName, data, hookId, httpStatus, error = NO_ERROR) => {
+const callerResponse = (cacheName, data, hookId, httpStatus, error = NO_ERROR, type = "result", requestId) => {
   self.postMessage({
+    type,
+    ...requestId != null && requestId !== "" && { requestId },
     cacheName,
-    data: error.message !== "" ? null : data ?? null,
+    data: type === "delete" ? null : error.message !== "" ? null : data ?? null,
     hookId,
     httpStatus,
     error
   });
 };
-const makeError = (message) => ({ message });
-const callerResponseBinary = (cacheName, data, meta, hookId, httpStatus, error = NO_ERROR) => {
+const makeError = (message, code) => code !== void 0 ? { message, code } : { message };
+const callerResponseBinary = (cacheName, data, meta, hookId, httpStatus, error = NO_ERROR, requestId) => {
   const buffer = data.byteLength ? data : EMPTY_BUFFER;
-  const payload = { cacheName, data: buffer, meta, hookId, httpStatus, error };
+  const payload = {
+    type: "result",
+    ...requestId != null && requestId !== "" && { requestId },
+    cacheName,
+    data: buffer,
+    meta,
+    hookId,
+    httpStatus,
+    error
+  };
   self.postMessage(payload, buffer.byteLength > 0 ? [buffer] : []);
 };
-const callerResponseStreamStart = (cacheName, meta, hookId, httpStatus, error = NO_ERROR) => {
+const callerResponseStreamStart = (cacheName, meta, hookId, httpStatus, error = NO_ERROR, requestId) => {
   self.postMessage({
+    type: "stream",
+    ...requestId != null && requestId !== "" && { requestId },
     cacheName,
     stream: "start",
     meta,
@@ -28,8 +41,10 @@ const callerResponseStreamStart = (cacheName, meta, hookId, httpStatus, error =
     error
   });
 };
-const callerResponseStreamResume = (cacheName, meta, hookId, httpStatus, error = NO_ERROR) => {
+const callerResponseStreamResume = (cacheName, meta, hookId, httpStatus, error = NO_ERROR, requestId) => {
   self.postMessage({
+    type: "stream",
+    ...requestId != null && requestId !== "" && { requestId },
     cacheName,
     stream: "resume",
     meta,
@@ -38,23 +53,52 @@ const callerResponseStreamResume = (cacheName, meta, hookId, httpStatus, error =
     error
   });
 };
-const callerResponseStreamChunk = (cacheName, data, hookId, error = NO_ERROR) => {
+const callerResponseStreamChunk = (cacheName, data, hookId, error = NO_ERROR, requestId) => {
   const buffer = data.byteLength ? data : EMPTY_BUFFER;
-  const payload = { cacheName, stream: "chunk", data: buffer, hookId, error };
+  const payload = {
+    type: "stream",
+    ...requestId != null && requestId !== "" && { requestId },
+    cacheName,
+    stream: "chunk",
+    data: buffer,
+    hookId,
+    error
+  };
   self.postMessage(payload, buffer.byteLength > 0 ? [buffer] : []);
 };
-const callerResponseStreamEnd = (cacheName, hookId, error = NO_ERROR) => {
-  self.postMessage({ cacheName, stream: "end", hookId, error });
+const callerResponseStreamEnd = (cacheName, hookId, error = NO_ERROR, requestId) => {
+  self.postMessage({
+    type: "stream",
+    ...requestId != null && requestId !== "" && { requestId },
+    cacheName,
+    stream: "end",
+    hookId,
+    error
+  });
 };
 const transferableBuffer = (view) => view.byteOffset === 0 && view.byteLength === view.buffer.byteLength ? view.buffer : view.slice(0).buffer;
 const store = /* @__PURE__ */ Object.create(null);
+const storeActivity = /* @__PURE__ */ new Map();
+const STALE_ENTRY_MS = 5e3;
+const CLEANUP_INTERVAL_MS = 3e4;
 const normalizeKey = (key) => key.toLocaleLowerCase();
-const get = (key) => store[normalizeKey(key)];
+const touchActivity = (key) => {
+  storeActivity.set(normalizeKey(key), Date.now());
+};
+const get = (key) => {
+  const nk = normalizeKey(key);
+  touchActivity(nk);
+  return store[nk];
+};
 const set = (key, value) => {
-  store[normalizeKey(key)] = value;
+  const nk = normalizeKey(key);
+  store[nk] = value;
+  touchActivity(nk);
 };
 const remove = (key) => {
-  delete store[normalizeKey(key)];
+  const nk = normalizeKey(key);
+  delete store[nk];
+  storeActivity.delete(nk);
 };
 const isNonEmptyString = (v) => typeof v === "string" && v.trim() !== "";
 const omitContentType = (headers) => {
@@ -64,13 +108,22 @@ const omitContentType = (headers) => {
   return rest;
 };
 const isBinaryResponse = (r) => typeof r === "object" && r !== null && BINARY_MARKER in r && r.data instanceof ArrayBuffer;
-const commit = (cacheName, data, hookId, httpStatus) => {
+const commit = (cacheName, data, hookId, httpStatus, requestId) => {
   if (!cacheName) {
-    callerResponse("", null, hookId, void 0, makeError("Invalid commit: cacheName is required"));
+    callerResponse(
+      "",
+      null,
+      hookId,
+      void 0,
+      makeError("Invalid commit: cacheName is required", "validation"),
+      "result",
+      requestId
+    );
     return;
   }
   set(cacheName, data);
-  callerResponse(cacheName, data, hookId, httpStatus);
+  touchActivity(cacheName);
+  callerResponse(cacheName, data, hookId, httpStatus, NO_ERROR, "result", requestId);
 };
 const parseResponseByContentType = async (response) => {
   const contentType = response.headers.get("content-type")?.toLocaleLowerCase() || "";
@@ -106,14 +159,14 @@ const appendToFormData = (formData, key, value, fileFieldName = DEFAULT_FILES_FI
     return true;
   }
   if (value !== null && value !== void 0 && typeof value === "object") {
-    const set2 = visited ?? /* @__PURE__ */ new WeakSet();
-    if (set2.has(value)) return false;
-    set2.add(value);
+    const visitedSet = visited ?? /* @__PURE__ */ new WeakSet();
+    if (visitedSet.has(value)) return false;
+    visitedSet.add(value);
     if (Array.isArray(value)) {
       let hasFile2 = false;
       let i = 0;
       while (i < value.length) {
-        hasFile2 = appendToFormData(formData, key ? `${key}.${i}` : String(i), value[i], fileFieldName, set2) || hasFile2;
+        hasFile2 = appendToFormData(formData, key ? `${key}.${i}` : String(i), value[i], fileFieldName, visitedSet) || hasFile2;
         i++;
       }
       return hasFile2;
@@ -128,7 +181,7 @@ const appendToFormData = (formData, key, value, fileFieldName = DEFAULT_FILES_FI
         key ? `${key}.${k}` : k,
         value[k],
         fileFieldName,
-        set2
+        visitedSet
       ) || hasFile;
       ki++;
     }
@@ -239,8 +292,8 @@ const prepareRequestBody = (payload, headers, options) => {
       return { headers: { ...headers } };
   }
 };
-const inFlightControllers = /* @__PURE__ */ new Map();
 const inFlightByCacheName = /* @__PURE__ */ new Map();
+const requestIdToCacheName = /* @__PURE__ */ new Map();
 const apiRequest = async (cacheName, payload, {
   url,
   method,
@@ -259,21 +312,32 @@ const apiRequest = async (cacheName, payload, {
   if (!skipInFlightDedupe) {
     const existing = inFlightByCacheName.get(cacheName);
     if (existing) {
+      if (requestId) {
+        existing.requestIds.add(requestId);
+        requestIdToCacheName.set(requestId, cacheName);
+      }
       const cached = get(cacheName);
-      if (cached !== void 0) callerResponse(cacheName, cached, hookId);
-      await existing;
+      if (cached !== void 0) callerResponse(cacheName, cached, hookId, void 0, NO_ERROR, "result", requestId);
+      await existing.promise;
       const fresh = get(cacheName);
-      if (fresh !== void 0) callerResponse(cacheName, fresh, hookId);
+      if (fresh !== void 0) callerResponse(cacheName, fresh, hookId, void 0, NO_ERROR, "result", requestId);
       return;
     }
   }
   const controller = new AbortController();
+  const requestIds = /* @__PURE__ */ new Set();
+  const inflightKey = skipInFlightDedupe && requestId ? requestId : cacheName;
   if (requestId) {
-    inFlightControllers.set(requestId, controller);
+    requestIds.add(requestId);
+    requestIdToCacheName.set(requestId, inflightKey);
   }
   let timeoutId;
+  let abortedByTimeout = false;
   if (timeoutMs != null && timeoutMs > 0) {
-    timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    timeoutId = setTimeout(() => {
+      abortedByTimeout = true;
+      controller.abort();
+    }, timeoutMs);
   }
   const promise = (async () => {
     const fetchOptions = {
@@ -299,6 +363,7 @@ const apiRequest = async (cacheName, payload, {
         let bytesReceived = 0;
         let streamError = NO_ERROR;
         let attempt = 0;
+        let isPermanentError = false;
         while (attempt <= maxRetries) {
           try {
             const reqHeaders = methodLower === "get" ? omitContentType({ ...fetchOptions.headers }) : { ...fetchOptions.headers };
@@ -308,24 +373,30 @@ const apiRequest = async (cacheName, payload, {
               headers: reqHeaders
             });
             if (streamResponse.status >= 400) {
-              streamError = makeError(streamResponse.statusText || DEFAULT_ERROR);
+              streamError = makeError(streamResponse.statusText || DEFAULT_ERROR, "http");
+              isPermanentError = true;
               break;
             }
             if (streamResponse.status === 204) {
-              callerResponseStreamEnd(cacheName, hookId);
+              callerResponseStreamEnd(cacheName, hookId, NO_ERROR, requestId);
               return;
             }
-            if (streamResponse.status === 416) break;
+            if (streamResponse.status === 416) {
+              streamError = makeError("Range Not Satisfiable", "http");
+              isPermanentError = true;
+              break;
+            }
             const contentType = streamResponse.headers.get("content-type") ?? void 0;
             const meta = {
               contentDisposition: streamResponse.headers.get("content-disposition") ?? null,
               ...contentType !== void 0 && { contentType }
             };
-            if (bytesReceived === 0) callerResponseStreamStart(cacheName, meta, hookId, streamResponse.status);
-            else callerResponseStreamResume(cacheName, meta, hookId, streamResponse.status);
+            if (bytesReceived === 0)
+              callerResponseStreamStart(cacheName, meta, hookId, streamResponse.status, NO_ERROR, requestId);
+            else callerResponseStreamResume(cacheName, meta, hookId, streamResponse.status, NO_ERROR, requestId);
             const body = streamResponse.body;
             if (!body) {
-              callerResponseStreamEnd(cacheName, hookId);
+              callerResponseStreamEnd(cacheName, hookId, NO_ERROR, requestId);
               return;
             }
             const reader = body.getReader();
@@ -342,31 +413,45 @@ const apiRequest = async (cacheName, payload, {
                 const offset = skipRemaining;
                 skipRemaining = 0;
                 const tail = value.subarray(offset);
-                callerResponseStreamChunk(cacheName, transferableBuffer(tail), hookId);
+                callerResponseStreamChunk(cacheName, transferableBuffer(tail), hookId, NO_ERROR, requestId);
                 bytesReceived += tail.byteLength;
               } else {
-                callerResponseStreamChunk(cacheName, transferableBuffer(value), hookId);
+                callerResponseStreamChunk(cacheName, transferableBuffer(value), hookId, NO_ERROR, requestId);
                 bytesReceived += value.byteLength;
               }
             }
             break;
           } catch (err) {
-            streamError = err.name === "AbortError" ? makeError("Request aborted") : makeError(err.message);
+            if (err.name === "AbortError") {
+              streamError = makeError("Request aborted", abortedByTimeout ? "timeout" : "aborted");
+              isPermanentError = true;
+              break;
+            }
+            streamError = makeError(err.message, "network");
             if (attempt === maxRetries) break;
           }
+          if (isPermanentError) break;
           attempt++;
         }
-        callerResponseStreamEnd(cacheName, hookId, streamError);
+        callerResponseStreamEnd(cacheName, hookId, streamError, requestId);
         return;
       }
       const response = await fetch(url, fetchOptions);
       if (response.status >= 400) {
-        callerResponse(cacheName, null, hookId, response.status, makeError(response.statusText || DEFAULT_ERROR));
+        callerResponse(
+          cacheName,
+          null,
+          hookId,
+          response.status,
+          makeError(response.statusText || DEFAULT_ERROR, "http"),
+          "result",
+          requestId
+        );
         return;
       }
       if (response.status === 204) {
         set(cacheName, null);
-        callerResponse(cacheName, null, hookId, 204);
+        callerResponse(cacheName, null, hookId, 204, NO_ERROR, "result", requestId);
         return;
       }
       const responseData = await parseResponseByContentType(response);
@@ -379,36 +464,52 @@ const apiRequest = async (cacheName, payload, {
             contentDisposition: responseData.contentDisposition ?? null
           },
           hookId,
-          response.status
+          response.status,
+          NO_ERROR,
+          requestId
         );
       } else {
-        commit(cacheName, responseData, hookId, response.status);
+        commit(cacheName, responseData, hookId, response.status, requestId);
       }
     } catch (error) {
       if (error.name === "AbortError") {
-        callerResponse(cacheName, null, hookId, void 0, makeError("Request aborted"));
+        callerResponse(
+          cacheName,
+          null,
+          hookId,
+          void 0,
+          makeError("Request aborted", abortedByTimeout ? "timeout" : "aborted"),
+          "result",
+          requestId
+        );
         return;
       }
       const err = error;
-      callerResponse(cacheName, null, hookId, void 0, makeError(err.message));
+      callerResponse(cacheName, null, hookId, void 0, makeError(err.message, "network"), "result", requestId);
     } finally {
       if (timeoutId != null) clearTimeout(timeoutId);
-      if (requestId) {
-        inFlightControllers.delete(requestId);
+      for (const id of requestIds) {
+        requestIdToCacheName.delete(id);
       }
-      inFlightByCacheName.delete(cacheName);
+      inFlightByCacheName.delete(inflightKey);
     }
   })();
-  if (!skipInFlightDedupe) {
-    inFlightByCacheName.set(cacheName, promise);
-  }
+  const entry = { promise, controller, requestIds };
+  inFlightByCacheName.set(inflightKey, entry);
   await promise;
 };
 const onRequest = (dataRequest) => {
   const { cacheName, type, payload, request, requestId, hookId } = dataRequest;
-  const responseCacheName = dataRequest.cacheName ?? "";
   if (!isNonEmptyString(type)) {
-    callerResponse(responseCacheName, null, hookId, void 0, makeError("Invalid request: type is required"));
+    callerResponse(
+      cacheName ?? "",
+      null,
+      hookId,
+      void 0,
+      makeError("Invalid request: type is required", "validation"),
+      "result",
+      requestId
+    );
     return;
   }
   const lowerType = normalizeKey(type);
@@ -417,26 +518,44 @@ const onRequest = (dataRequest) => {
     return;
   }
   if (!isNonEmptyString(cacheName)) {
-    callerResponse(responseCacheName, null, hookId, void 0, makeError("Invalid request: cacheName is required"));
+    callerResponse(
+      cacheName ?? "",
+      null,
+      hookId,
+      void 0,
+      makeError("Invalid request: cacheName is required", "validation"),
+      "result",
+      requestId
+    );
     return;
   }
   const lowerCacheName = normalizeKey(cacheName);
   if (lowerType === "get") {
     const requestedData = get(lowerCacheName);
     if (requestedData === void 0) {
-      callerResponse(lowerCacheName, null, hookId, void 0, makeError("Cache miss"));
+      callerResponse(
+        lowerCacheName,
+        null,
+        hookId,
+        void 0,
+        makeError("Cache miss", "validation"),
+        "result",
+        requestId
+      );
     } else {
-      callerResponse(lowerCacheName, requestedData, hookId);
+      callerResponse(lowerCacheName, requestedData, hookId, void 0, NO_ERROR, "result", requestId);
     }
   } else if (lowerType === "set") {
     if (!request) {
       if (payload == null) {
         callerResponse(
-          responseCacheName,
+          cacheName ?? "",
           null,
           hookId,
           void 0,
-          makeError("Invalid request: payload is required for set")
+          makeError("Invalid request: payload is required for set", "validation"),
+          "result",
+          requestId
         );
         return;
       }
@@ -445,11 +564,13 @@ const onRequest = (dataRequest) => {
       const methodLower = normalizeKey(request.method);
       if (methodLower !== "get" && payload == null) {
         callerResponse(
-          responseCacheName,
+          cacheName ?? "",
           null,
           hookId,
           void 0,
-          makeError("Invalid request: payload is required for non-GET API request")
+          makeError("Invalid request: payload is required for non-GET API request", "validation"),
+          "result",
+          requestId
         );
         return;
       }
@@ -457,16 +578,33 @@ const onRequest = (dataRequest) => {
     }
   } else if (lowerType === "delete") {
     remove(lowerCacheName);
-    callerResponse(lowerCacheName, { deleted: true }, hookId);
+    callerResponse(lowerCacheName, null, hookId, void 0, NO_ERROR, "delete", requestId);
   }
 };
 const onCancel = (requestId) => {
-  const controller = inFlightControllers.get(requestId);
-  if (controller) {
-    controller.abort();
-    inFlightControllers.delete(requestId);
+  const inflightKey = requestIdToCacheName.get(requestId);
+  if (!inflightKey) return;
+  const entry = inFlightByCacheName.get(inflightKey);
+  if (!entry) {
+    requestIdToCacheName.delete(requestId);
+    return;
+  }
+  entry.requestIds.delete(requestId);
+  requestIdToCacheName.delete(requestId);
+  if (entry.requestIds.size === 0) {
+    entry.controller.abort();
+  }
+};
+const runStaleStoreCleanup = () => {
+  const now = Date.now();
+  for (const [key, lastAccessAt] of storeActivity) {
+    if (now - lastAccessAt < STALE_ENTRY_MS) continue;
+    if (inFlightByCacheName.has(key)) continue;
+    delete store[key];
+    storeActivity.delete(key);
   }
 };
+setInterval(runStaleStoreCleanup, CLEANUP_INTERVAL_MS);
 onmessage = (event) => {
   const payload = event.data;
   if (payload === null || typeof payload !== "object") return;