@placeos/ts-client 4.2.3 → 4.2.5

package/package.json

@@ -1,5 +1,5 @@
 {
-    "version": "4.2.3",
+    "version": "4.2.5",
     "license": "MIT",
     "name": "@placeos/ts-client",
     "author": "Alex Sorafumo <alex@place.tech>",

package/src/http/functions.ts

@@ -1,6 +1,6 @@
-import { Observable, of, throwError } from 'rxjs';
+import { Observable, throwError } from 'rxjs';
 import { fromFetch } from 'rxjs/fetch';
-import { filter, mergeMap, retryWhen, switchMap, take } from 'rxjs/operators';
+import { filter, retry, switchMap, take } from 'rxjs/operators';
 
 import {
     apiKey,
@@ -225,17 +225,26 @@ export async function transform(
             return await resp.json().catch(() => ({}));
         case 'text':
             return await resp.text();
+        case 'void':
+            return;
+        default:
+            return await resp.json().catch(() => ({}));
     }
 }
 
 /**
  * @private
  */
-const reloadAuth = () => {
+const reloadAuth = (): Promise<void> => {
     invalidateToken();
-    refreshAuthority().then(
-        () => null,
-        () => setTimeout(() => reloadAuth(), 1000),
+    return refreshAuthority().then(
+        () => Promise.resolve(),
+        () =>
+            new Promise<void>((resolve) => {
+                setTimeout(() => {
+                    reloadAuth().then(() => resolve());
+                }, 1000);
+            }),
     );
 };
 
@@ -255,7 +264,7 @@ export function request(
         m: HttpVerb,
         url: string,
         body?: any,
-    ) => Observable<HttpResponse> | null = mockRequest,
+    ) => Observable<HashMap | string | void> | null = mockRequest,
     success: (
         e: Response,
         t: HttpResponseType,
@@ -263,12 +272,12 @@ export function request(
 ): Observable<HttpResponse> {
     if (is_mock()) {
         const request_obs = mock_handler(method, url, options?.body);
-        if (request_obs) {
-            return request_obs;
-        }
+        if (request_obs) return request_obs;
     }
     options.headers = options.headers || {};
-    options.headers['Content-Type'] = `application/json`;
+    if (!options.headers['Content-Type'] && !options.headers['content-type']) {
+        options.headers['Content-Type'] = `application/json`;
+    }
     return listenForToken().pipe(
         filter((_) => _),
         take(1),
@@ -278,34 +287,57 @@ export function request(
             } else {
                 options.headers!.Authorization = `Bearer ${token()}`;
             }
-            return fromFetch(url, {
+            const fetchOptions: any = {
                 ...options,
-                body: JSON.stringify(options.body),
                 method,
                 credentials: 'same-origin',
-            });
+            };
+
+            // Only add body for methods that support it and when body exists
+            if (
+                ['POST', 'PUT', 'PATCH'].includes(method) &&
+                options.body !== undefined
+            ) {
+                fetchOptions.body =
+                    typeof options.body === 'string'
+                        ? options.body
+                        : JSON.stringify(options.body);
+            }
+
+            return fromFetch(url, fetchOptions) as Observable<Response>;
         }),
-        switchMap((resp) => {
+        switchMap((resp: Response) => {
             if (resp.ok) {
                 return success(resp, options.response_type as any);
             }
             return throwError(resp);
         }),
-        retryWhen((attempts: Observable<any>) =>
-            attempts.pipe(
-                mergeMap((error, i) => {
+        retry({
+            count: 4,
+            delay: (error, retry_count) => {
+                return new Observable<number>((subscriber) => {
                     if (error.status === 511) {
                         sendToLogin(authority()!);
-                        return of(error);
+                        subscriber.error(error);
+                        return;
                     }
-                    if (i + 1 > 4 || error.status !== 401) {
-                        return throwError(error || {});
+                    if (error.status !== 401) {
+                        subscriber.error(error || {});
+                        return;
                     }
                     log('HTTP', 'Auth error', error);
-                    reloadAuth();
-                    return of(error);
-                }),
-            ),
-        ),
+                    // Wait for auth refresh before retrying with exponential backoff
+                    const delay_ms = Math.pow(2, retry_count - 1) * 1000; // Exponential backoff: 1s, 2s, 4s, 8s
+                    reloadAuth()
+                        .then(() => {
+                            subscriber.next(delay_ms);
+                            subscriber.complete();
+                        })
+                        .catch(() => {
+                            subscriber.error(error);
+                        });
+                });
+            },
+        }),
     );
 }

package/src/http/mock.ts

@@ -86,12 +86,15 @@ export function clearMockEndpoints(
  * @param handler_map Handler map to query for the request handler.
  *  Defaults to the global handler map
  */
-export function mockRequest<T>(
+export function mockRequest(
     method: HttpVerb,
     url: string,
     body?: any,
     handler_map: HashMap<MockHttpRequestHandler> = _handlers,
-): Observable<T> | null {
+): Observable<HashMap | string | void> | null {
+    if (window.debug) {
+        console.log('Resolving request:', method, url, body);
+    }
     const handler = findRequestHandler(method, url, handler_map);
     if (handler) {
         const request = processRequest(url, handler, body);
@@ -113,7 +116,7 @@ export function findRequestHandler(
     handler_map: HashMap<MockHttpRequestHandler> = _handlers,
 ): MockHttpRequestHandler | null {
     const path = url
-        .replace(/(http|https)?:\/\/[a-zA-Z0-9.]*:?([0-9]*)?/g, '')
+        .replace(/(http|https):\/\/[a-zA-Z0-9.]*:?([0-9]*)?/g, '')
         .replace(/^\//, '')
         .split('?')[0];
     const route_parts = path.split('/');
@@ -161,16 +164,16 @@ export function processRequest<T = any>(
     const parts = url
         .replace(/(http|https):\/\/[a-zA-Z0-9.]*:?([0-9]*)?/g, '')
         .split('?');
-    const path = parts[0].replace(/^\//g, '');
+    const path = parts[0].replace(/^\//, '');
     const query = parts[1] || '';
     const query_params = convertPairStringToMap(query);
     // Grab route parameters from URL
     const route_parts = path.split('/');
     const route_params: HashMap = {};
-    for (const part of handler.path_structure) {
-        if (part) {
-            route_params[part] =
-                route_parts[handler.path_structure.indexOf(part)];
+    for (let i = 0; i < handler.path_structure.length; i++) {
+        const paramName = handler.path_structure[i];
+        if (paramName) {
+            route_params[paramName] = route_parts[i];
         }
     }
     const request = {
@@ -196,9 +199,15 @@ export function onMockRequest(
     handler: MockHttpRequestHandler,
     request: MockHttpRequest,
 ) {
-    const result = handler.callback
-        ? handler.callback(request)
-        : handler.metadata;
+    let result;
+    try {
+        result = handler.callback
+            ? handler.callback(request)
+            : handler.metadata;
+    } catch (error) {
+        log('HTTP(M)', `ERROR ${request.method}:`, [request.url, error]);
+        throw error;
+    }
     const variance = handler.delay_variance || 100;
     const delay_value = handler.delay || 300;
     const delay_time =
@@ -206,3 +215,11 @@ export function onMockRequest(
     log('HTTP(M)', `RESP ${request.method}:`, [request.url, result]);
     return from([result]).pipe(delay(Math.max(200, delay_time)));
 }
+
+/**
+ * Get a list of the method + endpoints that have been mocked
+ * @returns List of the method + endpoint that have been mocked
+ */
+export function listMockedEndpoints(): string[] {
+    return Object.keys(_handlers);
+}