@mainframework/api-request-worker 1.0.2 → 1.0.4

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

@@ -1,44 +1,104 @@
 const BINARY_MARKER = /* @__PURE__ */ Symbol.for("WorkerApiBinary");
 const DEFAULT_FILES_FIELD = "Files";
+const EMPTY_BUFFER = new ArrayBuffer(0);
 const NO_ERROR = { message: "" };
-const callerResponse = (cacheName, data, hookId, httpStatus, error = NO_ERROR) => {
+const DEFAULT_ERROR = "An error occurred";
+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 buffer = data?.byteLength ? data : new ArrayBuffer(0);
-  const payload = { cacheName, data: buffer, meta, hookId, httpStatus, 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 = {
+    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) => {
-  self.postMessage({ cacheName, stream: "start", meta, hookId, httpStatus, error });
+const callerResponseStreamStart = (cacheName, meta, hookId, httpStatus, error = NO_ERROR, requestId) => {
+  self.postMessage({
+    type: "stream",
+    ...requestId != null && requestId !== "" && { requestId },
+    cacheName,
+    stream: "start",
+    meta,
+    hookId,
+    httpStatus,
+    error
+  });
 };
-const callerResponseStreamResume = (cacheName, meta, hookId, httpStatus, error = NO_ERROR) => {
-  self.postMessage({ cacheName, stream: "resume", meta, hookId, httpStatus, error });
+const callerResponseStreamResume = (cacheName, meta, hookId, httpStatus, error = NO_ERROR, requestId) => {
+  self.postMessage({
+    type: "stream",
+    ...requestId != null && requestId !== "" && { requestId },
+    cacheName,
+    stream: "resume",
+    meta,
+    hookId,
+    httpStatus,
+    error
+  });
 };
-const callerResponseStreamChunk = (cacheName, data, hookId, error = NO_ERROR) => {
-  const buffer = data?.byteLength ? data : new ArrayBuffer(0);
-  const payload = { cacheName, stream: "chunk", data: buffer, hookId, error };
+const callerResponseStreamChunk = (cacheName, data, hookId, error = NO_ERROR, requestId) => {
+  const buffer = data.byteLength ? data : EMPTY_BUFFER;
+  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) => {
@@ -48,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(normalizeKey(cacheName), data);
-  callerResponse(cacheName, data, hookId, httpStatus);
+  set(cacheName, data);
+  touchActivity(cacheName);
+  callerResponse(cacheName, data, hookId, httpStatus, NO_ERROR, "result", requestId);
 };
 const parseResponseByContentType = async (response) => {
   const contentType = response.headers.get("content-type")?.toLocaleLowerCase() || "";
@@ -63,7 +132,11 @@ const parseResponseByContentType = async (response) => {
     return null;
   }
   if (contentType.includes("json")) {
-    return await response.json();
+    const text = await response.text();
+    if (text.trim() === "") {
+      return null;
+    }
+    return JSON.parse(text);
   }
   if (contentType.startsWith("text/") || contentType.includes("xml") || contentType.includes("javascript") || contentType.includes("x-www-form-urlencoded")) {
     return await response.text();
@@ -86,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;
@@ -103,22 +176,20 @@ const appendToFormData = (formData, key, value, fileFieldName = DEFAULT_FILES_FI
     let ki = 0;
     while (ki < keys.length) {
       const k = keys[ki];
-      if (Object.prototype.hasOwnProperty.call(value, k)) {
-        hasFile = appendToFormData(
-          formData,
-          key ? `${key}.${k}` : k,
-          value[k],
-          fileFieldName,
-          set2
-        ) || hasFile;
-      }
+      hasFile = appendToFormData(
+        formData,
+        key ? `${key}.${k}` : k,
+        value[k],
+        fileFieldName,
+        visitedSet
+      ) || hasFile;
       ki++;
     }
     return hasFile;
   }
   if (value !== void 0 && value !== null) {
     const primitive = value;
-    formData.append(key, primitive);
+    formData.append(key, String(primitive));
   }
   return false;
 };
@@ -151,13 +222,32 @@ const getPayloadType = (payload) => {
   }
 };
 const buildJsonBody = (payload) => JSON.stringify(payload);
-const buildUrlEncodedBody = (payload) => new URLSearchParams(payload).toString();
+const buildUrlEncodedBody = (payload) => {
+  const params = new URLSearchParams();
+  const keys = Object.keys(payload);
+  let i = 0;
+  while (i < keys.length) {
+    const key = keys[i];
+    const value = payload[key];
+    if (value !== null && value !== void 0) {
+      if (typeof value === "object") {
+        throw new Error(`Cannot url-encode non-primitive value for key "${key}"`);
+      }
+      params.append(key, value.toString());
+    }
+    i++;
+  }
+  return params.toString();
+};
 const buildTextBody = (payload) => String(payload);
 const prepareRequestBody = (payload, headers, options) => {
   const payloadType = getPayloadType(payload);
   switch (payloadType) {
     case "formdata":
-      return { body: payload, headers: omitContentType({ ...headers }) };
+      return {
+        body: payload,
+        headers: omitContentType({ ...headers })
+      };
     case "blob":
       return { body: payload, headers: { ...headers } };
     case "arraybuffer":
@@ -165,28 +255,31 @@ const prepareRequestBody = (payload, headers, options) => {
     case "arraybufferview":
       return { body: payload, headers: { ...headers } };
     case "stream":
-      return { body: payload, headers: { ...headers } };
+      return {
+        body: payload,
+        headers: { ...headers }
+      };
     case "string":
       return { body: payload, headers: { ...headers } };
     case "object": {
-      const h = { ...headers };
-      const contentType = getContentType(h);
       const fileFieldName = options?.formDataFileFieldName ?? DEFAULT_FILES_FIELD;
       const formDataKey = options?.formDataKey ?? DEFAULT_FILES_FIELD;
+      const formData = createFormDataIfBlobOrFile(payload, fileFieldName, formDataKey);
+      if (formData) {
+        return { body: formData, headers: omitContentType({ ...headers }) };
+      }
+      const h = { ...headers };
+      let contentType = getContentType(h);
+      if (contentType.includes("multipart/form-data")) {
+        contentType = "application/json";
+        delete h["Content-Type"];
+        delete h["content-type"];
+      }
       let body;
-      if (contentType.includes("application/json")) {
-        body = buildJsonBody(payload);
-      } else if (contentType.includes("application/x-www-form-urlencoded")) {
+      if (contentType.includes("application/x-www-form-urlencoded")) {
         body = buildUrlEncodedBody(payload);
       } else if (contentType.startsWith("text/") || contentType.includes("xml")) {
         body = buildTextBody(payload);
-      } else if (contentType.includes("multipart/form-data")) {
-        const formData = createFormDataIfBlobOrFile(payload, fileFieldName, formDataKey);
-        if (formData) {
-          return { body: formData, headers: omitContentType(h) };
-        }
-        body = buildJsonBody(payload);
-        h["Content-Type"] = "application/json";
       } else {
         body = buildJsonBody(payload);
       }
@@ -199,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,
@@ -219,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 = {
@@ -242,47 +346,57 @@ const apiRequest = async (cacheName, payload, {
       credentials,
       signal: controller.signal
     };
-    if (methodLower !== "get" && payload != null) {
-      const prepareOptions = {};
-      if (formDataFileFieldName != null && formDataFileFieldName !== "")
-        prepareOptions.formDataFileFieldName = formDataFileFieldName;
-      if (formDataKey != null && formDataKey !== "") prepareOptions.formDataKey = formDataKey;
-      const { body, headers: processedHeaders } = prepareRequestBody(payload, headers, prepareOptions);
-      if (body !== void 0) fetchOptions.body = body;
-      fetchOptions.headers = processedHeaders;
-    } else {
-      fetchOptions.headers = omitContentType({ ...headers });
-    }
     try {
+      if (methodLower !== "get" && payload != null) {
+        const prepareOptions = {};
+        if (formDataFileFieldName != null && formDataFileFieldName !== "")
+          prepareOptions.formDataFileFieldName = formDataFileFieldName;
+        if (formDataKey != null && formDataKey !== "") prepareOptions.formDataKey = formDataKey;
+        const { body, headers: processedHeaders } = prepareRequestBody(payload, headers, prepareOptions);
+        if (body !== void 0) fetchOptions.body = body;
+        fetchOptions.headers = processedHeaders;
+      } else {
+        fetchOptions.headers = omitContentType({ ...headers });
+      }
       if (responseTypeLower === "stream") {
         const maxRetries = Math.min(retries ?? 3, 5);
         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;
+            const reqHeaders = methodLower === "get" ? omitContentType({ ...fetchOptions.headers }) : { ...fetchOptions.headers };
             if (bytesReceived > 0) reqHeaders["Range"] = `bytes=${bytesReceived}-`;
-            const streamResponse = await fetch(url, { ...fetchOptions, headers: reqHeaders });
+            const streamResponse = await fetch(url, {
+              ...fetchOptions,
+              headers: reqHeaders
+            });
             if (streamResponse.status >= 400) {
-              streamError = makeError(streamResponse.statusText);
+              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();
@@ -299,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));
+        callerResponse(
+          cacheName,
+          null,
+          hookId,
+          response.status,
+          makeError(response.statusText || DEFAULT_ERROR, "http"),
+          "result",
+          requestId
+        );
         return;
       }
       if (response.status === 204) {
-        set(normalizeKey(cacheName), null);
-        callerResponse(cacheName, null, hookId, 204);
+        set(cacheName, null);
+        callerResponse(cacheName, null, hookId, 204, NO_ERROR, "result", requestId);
         return;
       }
       const responseData = await parseResponseByContentType(response);
@@ -336,34 +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);
     }
   })();
-  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);
@@ -372,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;
       }
@@ -400,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;
       }
@@ -412,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;