@izak0s/spacebring-api 1.0.0 → 1.2.0

package/dist/index.js

@@ -13,24 +13,27 @@ function createClient(clientOptions) {
     fetch: baseFetch = globalThis.fetch,
     querySerializer: globalQuerySerializer,
     bodySerializer: globalBodySerializer,
+    pathSerializer: globalPathSerializer,
     headers: baseHeaders,
     requestInitExt = void 0,
     ...baseOptions
   } = { ...clientOptions };
   requestInitExt = supportsRequestInitExt() ? requestInitExt : void 0;
   baseUrl = removeTrailingSlash(baseUrl);
-  const middlewares = [];
+  const globalMiddlewares = [];
   async function coreFetch(schemaPath, fetchOptions) {
     const {
       baseUrl: localBaseUrl,
       fetch = baseFetch,
-      Request = CustomRequest,
+      Request: Request2 = CustomRequest,
       headers,
       params = {},
       parseAs = "json",
       querySerializer: requestQuerySerializer,
       bodySerializer = globalBodySerializer ?? defaultBodySerializer,
+      pathSerializer: requestPathSerializer,
       body,
+      middleware: requestMiddlewares = [],
       ...init
     } = fetchOptions || {};
     let finalBaseUrl = baseUrl;
@@ -44,6 +47,7 @@ function createClient(clientOptions) {
         ...requestQuerySerializer
       });
     }
+    const pathSerializer = requestPathSerializer || globalPathSerializer || defaultPathSerializer;
     const serializedBody = body === void 0 ? void 0 : bodySerializer(
       body,
       // Note: we declare mergeHeaders() both here and below because it’s a bit of a chicken-or-egg situation:
@@ -63,6 +67,7 @@ function createClient(clientOptions) {
       headers,
       params.header
     );
+    const finalMiddlewares = [...globalMiddlewares, ...requestMiddlewares];
     const requestInit = {
       redirect: "follow",
       ...baseOptions,
@@ -72,8 +77,8 @@ function createClient(clientOptions) {
     };
     let id;
     let options;
-    let request = new Request(
-      createFinalURL(schemaPath, { baseUrl: finalBaseUrl, params, querySerializer }),
+    let request = new Request2(
+      createFinalURL(schemaPath, { baseUrl: finalBaseUrl, params, querySerializer, pathSerializer }),
       requestInit
     );
     let response;
@@ -82,16 +87,17 @@ function createClient(clientOptions) {
         request[key] = init[key];
       }
     }
-    if (middlewares.length) {
+    if (finalMiddlewares.length) {
       id = randomID();
       options = Object.freeze({
         baseUrl: finalBaseUrl,
         fetch,
         parseAs,
         querySerializer,
-        bodySerializer
+        bodySerializer,
+        pathSerializer
       });
-      for (const m of middlewares) {
+      for (const m of finalMiddlewares) {
         if (m && typeof m === "object" && typeof m.onRequest === "function") {
           const result = await m.onRequest({
             request,
@@ -101,7 +107,7 @@ function createClient(clientOptions) {
             id
           });
           if (result) {
-            if (result instanceof Request) {
+            if (result instanceof Request2) {
               request = result;
             } else if (result instanceof Response) {
               response = result;
@@ -118,9 +124,9 @@ function createClient(clientOptions) {
         response = await fetch(request, requestInitExt);
       } catch (error2) {
         let errorAfterMiddleware = error2;
-        if (middlewares.length) {
-          for (let i = middlewares.length - 1; i >= 0; i--) {
-            const m = middlewares[i];
+        if (finalMiddlewares.length) {
+          for (let i = finalMiddlewares.length - 1; i >= 0; i--) {
+            const m = finalMiddlewares[i];
             if (m && typeof m === "object" && typeof m.onError === "function") {
               const result = await m.onError({
                 request,
@@ -149,9 +155,9 @@ function createClient(clientOptions) {
           throw errorAfterMiddleware;
         }
       }
-      if (middlewares.length) {
-        for (let i = middlewares.length - 1; i >= 0; i--) {
-          const m = middlewares[i];
+      if (finalMiddlewares.length) {
+        for (let i = finalMiddlewares.length - 1; i >= 0; i--) {
+          const m = finalMiddlewares[i];
           if (m && typeof m === "object" && typeof m.onResponse === "function") {
             const result = await m.onResponse({
               request,
@@ -171,14 +177,22 @@ function createClient(clientOptions) {
         }
       }
     }
-    if (response.status === 204 || request.method === "HEAD" || response.headers.get("Content-Length") === "0") {
+    const contentLength = response.headers.get("Content-Length");
+    if (response.status === 204 || request.method === "HEAD" || contentLength === "0" && !response.headers.get("Transfer-Encoding")?.includes("chunked")) {
       return response.ok ? { data: void 0, response } : { error: void 0, response };
     }
     if (response.ok) {
-      if (parseAs === "stream") {
-        return { data: response.body, response };
-      }
-      return { data: await response[parseAs](), response };
+      const getResponseData = async () => {
+        if (parseAs === "stream") {
+          return response.body;
+        }
+        if (parseAs === "json" && !contentLength) {
+          const raw = await response.text();
+          return raw ? JSON.parse(raw) : void 0;
+        }
+        return await response[parseAs]();
+      };
+      return { data: await getResponseData(), response };
     }
     let error = await response.text();
     try {
@@ -232,15 +246,15 @@ function createClient(clientOptions) {
         if (typeof m !== "object" || !("onRequest" in m || "onResponse" in m || "onError" in m)) {
           throw new Error("Middleware must be an object with one of `onRequest()`, `onResponse() or `onError()`");
         }
-        middlewares.push(m);
+        globalMiddlewares.push(m);
       }
     },
     /** Unregister middleware */
     eject(...middleware) {
       for (const m of middleware) {
-        const i = middlewares.indexOf(m);
+        const i = globalMiddlewares.indexOf(m);
         if (i !== -1) {
-          middlewares.splice(i, 1);
+          globalMiddlewares.splice(i, 1);
         }
       }
     }
@@ -421,7 +435,7 @@ function defaultBodySerializer(body, headers) {
 function createFinalURL(pathname, options) {
   let finalURL = `${options.baseUrl}${pathname}`;
   if (options.params?.path) {
-    finalURL = defaultPathSerializer(finalURL, options.params.path);
+    finalURL = options.pathSerializer(finalURL, options.params.path);
   }
   let search = options.querySerializer(options.params.query ?? {});
   if (search.startsWith("?")) {
@@ -1681,8 +1695,8 @@ function createSubscriptions(client, defaults) {
      *
      * Retrieve a certain subscription.
      */
-    async get(id) {
-      return unwrapProp(await client.GET("/subscriptions/v1/{id}", { params: { path: { id } } }), "subscription");
+    async get(subscriptionId) {
+      return unwrapProp(await client.GET("/subscriptions/v1/{subscriptionId}", { params: { path: { subscriptionId } } }), "subscription");
     },
     /**
      * Create a subscription
@@ -1697,28 +1711,28 @@ function createSubscriptions(client, defaults) {
      *
      * Update a certain subscription.
      */
-    async update(id, body) {
-      return unwrap(await client.PATCH("/subscriptions/v1/{id}", { params: { path: { id } }, body }));
+    async update(subscriptionId, body) {
+      return unwrap(await client.PATCH("/subscriptions/v1/{subscriptionId}", { params: { path: { subscriptionId } }, body }));
     },
     /**
      * Delete a subscription
      *
      * Delete a certain subscription.
      */
-    async delete(id) {
-      return unwrap(await client.DELETE("/subscriptions/v1/{id}", { params: { path: { id } } }));
+    async delete(subscriptionId) {
+      return unwrap(await client.DELETE("/subscriptions/v1/{subscriptionId}", { params: { path: { subscriptionId } } }));
     },
     /** Create a subscription item */
-    async createItem(id, body) {
-      return unwrapProp(await client.POST("/subscriptions/v1/{id}/items", { params: { path: { id } }, body }), "subscription");
+    async createItem(subscriptionId, body) {
+      return unwrapProp(await client.POST("/subscriptions/v1/{subscriptionId}/items", { params: { path: { subscriptionId } }, body }), "subscription");
     },
     /** Delete a subscription item */
-    async deleteItem(id, itemId) {
-      return unwrap(await client.DELETE("/subscriptions/v1/{id}/items/{itemId}", { params: { path: { id, itemId } } }));
+    async deleteItem(subscriptionId, itemId) {
+      return unwrap(await client.DELETE("/subscriptions/v1/{subscriptionId}/items/{itemId}", { params: { path: { subscriptionId, itemId } } }));
     },
     /** Update a subscription item */
-    async updateItem(id, itemId, body) {
-      return unwrap(await client.PATCH("/subscriptions/v1/{id}/items/{itemId}", { params: { path: { id, itemId } }, body }));
+    async updateItem(subscriptionId, itemId, body) {
+      return unwrap(await client.PATCH("/subscriptions/v1/{subscriptionId}/items/{itemId}", { params: { path: { subscriptionId, itemId } }, body }));
     }
   };
 }
@@ -2048,11 +2062,25 @@ var Spacebring = class {
     this.raw = createClient({
       baseUrl: config.baseUrl ?? "https://api.spacebring.com",
       headers,
-      fetch: config.fetch
+      fetch: withRetry(config.fetch ?? globalThis.fetch, config.maxRetries ?? 3)
     });
     Object.assign(this, createResources2(this.raw, { networkId: config.networkId }));
   }
 };
+function withRetry(fetchImpl, maxRetries) {
+  if (maxRetries <= 0) return fetchImpl;
+  return async (input, init) => {
+    const request = input instanceof Request && init === void 0 ? input : new Request(input, init);
+    for (let attempt = 0; ; attempt += 1) {
+      const response = await fetchImpl(request.clone());
+      if (response.status !== 429 || attempt >= maxRetries) return response;
+      const retryAfterHeader = response.headers.get("retry-after");
+      const retryAfter = retryAfterHeader === null ? Number.NaN : Number(retryAfterHeader);
+      const delayMs = Number.isFinite(retryAfter) && retryAfter >= 0 ? Math.min(retryAfter * 1e3, 6e4) : Math.min(250 * 2 ** attempt + Math.random() * 100, 5e3);
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+  };
+}
 function toBase64(value) {
   if (typeof Buffer !== "undefined") {
     return Buffer.from(value, "utf8").toString("base64");