@streamlayer/sdk-web-api 0.22.0 → 0.23.0

package/lib/grpc/queries/organization.d.ts

@@ -17,5 +17,7 @@ export declare const $organizationSettings: ($enabled: ReadableAtom<'on' | undef
     brandDefaults?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").BrandDefaults | undefined;
     pub?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").JWK | undefined;
     getstream?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").GetStreamSettingsClient | undefined;
+    publicName?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").PublicName | undefined;
+    analyticsVersion?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").AnalyticsVersion | undefined;
 } | undefined, any>;
 export declare const $organizationAdvertising: ($enabled: ReadableAtom<string | undefined>, transport: Transport) => import("@nanostores/query").FetcherStore<import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").Advertising | undefined, any>;

package/lib/grpc/queries/user.js

@@ -13,10 +13,11 @@ export const $user = ($userToken, transport) => {
     });
 };
 export const bypassLogin = (transport) => {
-    const { client } = transport.createPromiseClient(Users, { method: 'bypassAuth' });
+    const { client, createRequestOptions } = transport.createPromiseClient(Users, { method: 'bypassAuth' });
+    const contextValues = createRequestOptions({ retryAttempts: 0 });
     // inviterKey to do add to payload, ONLY after implement it on backend!
     return async ({ userKey, schema, init, inviterKey }) => {
-        const res = await client.bypassAuth({ userKey, schema, init });
+        const res = await client.bypassAuth({ userKey, schema, init }, { contextValues });
         if (res.meta) {
             res.meta.inviterKey = inviterKey;
         }
@@ -24,8 +25,9 @@ export const bypassLogin = (transport) => {
     };
 };
 export const bypassAuth = (transport, params) => {
-    const { client } = transport.createPromiseClient(Users, { method: 'bypassAuth' });
-    return client.bypassAuth(params);
+    const { client, createRequestOptions } = transport.createPromiseClient(Users, { method: 'bypassAuth' });
+    const contextValues = createRequestOptions({ retryAttempts: 0 });
+    return client.bypassAuth(params, { contextValues });
 };
 export const $userSettings = ($userToken, // sl user token
 transport) => {
@@ -38,6 +40,7 @@ transport) => {
     });
 };
 export const register = (transport, phone) => {
-    const { client } = transport.createPromiseClient(Users, { method: 'register' });
-    return client.register({ id: phone });
+    const { client, createRequestOptions } = transport.createPromiseClient(Users, { method: 'register' });
+    const contextValues = createRequestOptions({ retryAttempts: 0 });
+    return client.register({ id: phone }, { contextValues });
 };

package/lib/grpc/retry.d.ts

@@ -0,0 +1,49 @@
+import { type Interceptor } from '@connectrpc/connect';
+/**
+ * Retry interceptor
+ *
+ * This interceptor is used to retry requests in case of network errors.
+ * Retries are performed according to the exponential backoff algorithm.
+ * Allowing retries for the following error codes:
+ *  [
+ *    Code.Unknown,
+ *    Code.Internal,
+ *    Code.DeadlineExceeded,
+ *    Code.ResourceExhausted,
+ *    Code.FailedPrecondition,
+ *    Code.Unavailable,
+ *    Code.DataLoss,
+ *  ]
+ *
+ * Retry params:
+ * - retryAttempts: number of attempts to retry the request, 0 means no retries
+ * - retryDelay: max delay between retries in milliseconds
+ *
+ * Example:
+ * ```ts
+    const { client, createRequestOptions, queryKey } = transport.createPromiseClient(Leaderboard, {
+      method: 'summary',
+      params: [$eventId, $userId],
+    })
+
+    return transport.nanoquery.createFetcherStore(queryKey, {
+      fetcher: async (_, __, eventId, userId) => {
+        const contextValues = createRequestOptions({
+          retryAttempts: 5,
+          retryDelay: 10000,
+        })
+
+        const res = await client.summary(
+          {
+            eventId: eventId as unknown as bigint,
+            userId: userId as string,
+          },
+          { contextValues }
+        )
+
+        return res.data?.attributes
+      },
+    })
+ * ```
+ */
+export declare const retry: Interceptor;

package/lib/grpc/retry.js

@@ -0,0 +1,87 @@
+import { createLogger } from '@streamlayer/sdk-web-logger';
+import { Code, ConnectError } from '@connectrpc/connect';
+import { RequestOptionsKeys } from './transport';
+const allowedRetryFor = new Set([
+    Code.Unknown,
+    Code.Internal,
+    Code.DeadlineExceeded,
+    Code.ResourceExhausted,
+    Code.FailedPrecondition,
+    Code.Unavailable,
+    Code.DataLoss,
+]);
+const log = createLogger('grpc:retry');
+/**
+ * Retry interceptor
+ *
+ * This interceptor is used to retry requests in case of network errors.
+ * Retries are performed according to the exponential backoff algorithm.
+ * Allowing retries for the following error codes:
+ *  [
+ *    Code.Unknown,
+ *    Code.Internal,
+ *    Code.DeadlineExceeded,
+ *    Code.ResourceExhausted,
+ *    Code.FailedPrecondition,
+ *    Code.Unavailable,
+ *    Code.DataLoss,
+ *  ]
+ *
+ * Retry params:
+ * - retryAttempts: number of attempts to retry the request, 0 means no retries
+ * - retryDelay: max delay between retries in milliseconds
+ *
+ * Example:
+ * ```ts
+    const { client, createRequestOptions, queryKey } = transport.createPromiseClient(Leaderboard, {
+      method: 'summary',
+      params: [$eventId, $userId],
+    })
+
+    return transport.nanoquery.createFetcherStore(queryKey, {
+      fetcher: async (_, __, eventId, userId) => {
+        const contextValues = createRequestOptions({
+          retryAttempts: 5,
+          retryDelay: 10000,
+        })
+
+        const res = await client.summary(
+          {
+            eventId: eventId as unknown as bigint,
+            userId: userId as string,
+          },
+          { contextValues }
+        )
+
+        return res.data?.attributes
+      },
+    })
+ * ```
+ */
+export const retry = (next) => {
+    return async (req) => {
+        const attempts = req.contextValues.get(RequestOptionsKeys.retryAttempts);
+        const minDelay = 300;
+        const maxDelay = req.contextValues.get(RequestOptionsKeys.retryDelay);
+        if (req.stream || attempts === 0) {
+            return next(req);
+        }
+        log.trace({ url: req.url, attempts, maxDelay }, 'retry options');
+        for (let attempt = 0;; attempt++) {
+            try {
+                return await next(req);
+            }
+            catch (error) {
+                log.trace({ attempt, error }, 'retry attempt');
+                const cErr = ConnectError.from(error);
+                if (attempt >= attempts || !(cErr instanceof ConnectError) || !allowedRetryFor.has(cErr.code)) {
+                    throw error;
+                }
+                // https://aws.amazon.com/ru/blogs/architecture/exponential-backoff-and-jitter/
+                const backoff = Math.min(maxDelay, Math.pow(2, attempt) * minDelay);
+                const delayMs = Math.round((backoff * (1 + Math.random())) / 2);
+                await new Promise((resolve) => setTimeout(resolve, delayMs));
+            }
+        }
+    };
+};

package/lib/grpc/transport.d.ts

@@ -25,6 +25,12 @@ type NanoqueryObjectType = {
     createMutatorStore: NanoqueryReturnType[1];
     utils: NanoqueryReturnType[2];
 };
+export declare const RequestOptionsKeys: {
+    retryAttempts: import("@connectrpc/connect").ContextKey<number>;
+    retryDelay: import("@connectrpc/connect").ContextKey<number>;
+};
+type RequestOptionsKey = keyof typeof RequestOptionsKeys;
+type RequestOptions = Partial<Record<RequestOptionsKey, (typeof RequestOptionsKeys)[RequestOptionsKey]['defaultValue']>>;
 /**
  * transport wrapper, initialize grpc transport, store headers and connect interceptors
  */
@@ -56,6 +62,7 @@ export declare class Transport {
         method: keyof T["methods"];
     }) => {
         client: PromiseClient<T>;
+        createRequestOptions: (options: RequestOptions) => import("@connectrpc/connect").ContextValues;
         queryKey: ((string | number | true) | import("nanostores").ReadableAtom<(string | number | true) | (false | void | null | undefined)> | import("@nanostores/query").FetcherStore<any, any>)[];
         queryKeyStr: string;
     };

package/lib/grpc/transport.js

@@ -2,9 +2,15 @@ import { MapStore, createMapStore } from '@streamlayer/sdk-web-interfaces';
 import { nanoid } from 'nanoid';
 import { createRouterTransport, createPromiseClient, } from '@connectrpc/connect';
 import { createGrpcWebTransport } from '@connectrpc/connect-web';
+import { createContextValues, createContextKey } from '@connectrpc/connect';
 import { nanoquery } from '@nanostores/query';
 import { __GRPC_DEVTOOLS_EXTENSION__ } from '../utils/devtools';
 import { ServerStreamSubscription } from './subscription';
+import { retry } from './retry';
+export const RequestOptionsKeys = {
+    retryAttempts: createContextKey(5, { description: 'Number of attempts to retry' }),
+    retryDelay: createContextKey(30000, { description: 'Max delay between retries in milliseconds' }),
+};
 // generate random device id and store it in local storage
 const getDeviceId = () => {
     const deviceId = localStorage.getItem('sl-device-id');
@@ -48,7 +54,7 @@ export class Transport {
         this.nanoquery = { createFetcherStore, createMutatorStore, utils };
         this.transport = createGrpcWebTransport({
             baseUrl: host,
-            defaultTimeoutMs: 30000,
+            defaultTimeoutMs: 10000,
             interceptors: this.interceptors,
             useBinaryFormat: true,
         });
@@ -127,7 +133,15 @@ export class Transport {
             ...(Array.isArray(params) ? params : [params]),
         ];
         const queryKeyWithoutParams = [service.typeName, methodName.charAt(0).toLowerCase() + methodName.slice(1)];
-        return { client, queryKey, queryKeyStr: queryKeyWithoutParams.join('') };
+        const createRequestOptions = (options) => {
+            const contextValues = createContextValues();
+            for (const option in options) {
+                const contextKey = RequestOptionsKeys[option];
+                contextValues.set(contextKey, options[option]);
+            }
+            return contextValues;
+        };
+        return { client, createRequestOptions, queryKey, queryKeyStr: queryKeyWithoutParams.join('') };
     };
     // create promise client, used for server stream subscriptions
     createStreamClient = (service) => {
@@ -159,6 +173,7 @@ export class Transport {
         if (process.env.NODE_ENV !== 'test') {
             this.interceptors.push(__GRPC_DEVTOOLS_EXTENSION__());
         }
+        this.interceptors.push(retry);
         // if (window.__GRPC_DEVTOOLS_EXTENSION__) {
         //   this.interceptors.push(window.__GRPC_DEVTOOLS_EXTENSION__())
         // } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@streamlayer/sdk-web-api",
-  "version": "0.22.0",
+  "version": "0.23.0",
   "type": "module",
   "main": "./lib/index.js",
   "typings": "./lib/index.d.ts",
@@ -21,14 +21,15 @@
     }
   },
   "dependencies": {
-    "@streamlayer/sdk-web-interfaces": "^0.20.5"
+    "@streamlayer/sdk-web-interfaces": "^0.20.6",
+    "@streamlayer/sdk-web-logger": "^0.5.17"
   },
   "devDependencies": {
-    "@bufbuild/protobuf": "^1.6.0",
+    "@bufbuild/protobuf": "^1.7.2",
     "@connectrpc/connect": "^1.3.0",
     "@connectrpc/connect-web": "^1.3.0",
     "@nanostores/query": "^0.2.9",
-    "@streamlayer/sl-eslib": "^5.67.0",
+    "@streamlayer/sl-eslib": "^5.79.3",
     "@swc/helpers": "^0.5.3",
     "nanoid": "3.3.7",
     "nanostores": "^0.9.5",