@streamlayer/sdk-web-api 0.22.0 → 0.24.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

@@ -1,14 +1,15 @@
+import { MapStore } from '@streamlayer/sdk-web-interfaces';
 import { createRouterTransport, ConnectRouter, Interceptor, PromiseClient, UnaryRequest, StreamRequest } from '@connectrpc/connect';
 import type { ServiceType, Message, PlainMessage } from '@bufbuild/protobuf';
 import { createGrpcWebTransport } from '@connectrpc/connect-web';
-import type { KeyInput } from '@nanostores/query';
-import { nanoquery } from '@nanostores/query';
+import { type KeyInput, nanoquery } from '@nanostores/query';
 import { Atom } from 'nanostores';
 import { ServerStreamSubscription, type ServerStreamSubscriptionOptions } from './subscription';
 type KnownHeaders = {
     authorization?: string;
     sdk?: string;
     'sl-device-id': string;
+    'sl-device-os': string;
     'sl-user-id'?: string;
 } & Record<string, string>;
 export type GrpcTransport = Transport['transport'];
@@ -25,6 +26,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
  */
@@ -38,10 +45,10 @@ export declare class Transport {
     readonly streamTransport: ReturnType<typeof createGrpcWebTransport>;
     readonly nanoquery: NanoqueryObjectType;
     readonly host: string;
+    readonly $headers: MapStore<KnownHeaders>;
     protected interceptors: Interceptor[];
-    private readonly $headers;
     private clients;
-    private callbackClients;
+    private streamClients;
     private subscriptions;
     constructor(host: string);
     addSubscription: <T extends ServiceType, Req extends Message<Req>, Res extends Message<Res>>(method: { [P in keyof PromiseClient<T> as T["methods"][P] extends import("@bufbuild/protobuf").MethodInfoServerStreaming<any, any> ? P : never]: T["methods"][P] extends import("@bufbuild/protobuf").MethodInfoServerStreaming<any, any> ? PromiseClient<T>[P] : never; }[keyof { [P in keyof PromiseClient<T> as T["methods"][P] extends import("@bufbuild/protobuf").MethodInfoServerStreaming<any, any> ? P : never]: T["methods"][P] extends import("@bufbuild/protobuf").MethodInfoServerStreaming<any, any> ? PromiseClient<T>[P] : never; }], params: PlainMessage<Req> | Atom<PlainMessage<Req>>, options: ServerStreamSubscriptionOptions) => ServerStreamSubscription<ServiceType, Message<import("@bufbuild/protobuf").AnyMessage>, Message<import("@bufbuild/protobuf").AnyMessage>, never, never> | ServerStreamSubscription<T, Req, Res, keyof { [P in keyof PromiseClient<T> as T["methods"][P] extends import("@bufbuild/protobuf").MethodInfoServerStreaming<any, any> ? P : never]: T["methods"][P] extends import("@bufbuild/protobuf").MethodInfoServerStreaming<any, any> ? PromiseClient<T>[P] : never; }, { [P in keyof PromiseClient<T> as T["methods"][P] extends import("@bufbuild/protobuf").MethodInfoServerStreaming<any, any> ? P : never]: T["methods"][P] extends import("@bufbuild/protobuf").MethodInfoServerStreaming<any, any> ? PromiseClient<T>[P] : never; }[keyof { [P in keyof PromiseClient<T> as T["methods"][P] extends import("@bufbuild/protobuf").MethodInfoServerStreaming<any, any> ? P : never]: T["methods"][P] extends import("@bufbuild/protobuf").MethodInfoServerStreaming<any, any> ? PromiseClient<T>[P] : never; }]>;
@@ -56,6 +63,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

@@ -1,10 +1,15 @@
 import { MapStore, createMapStore } from '@streamlayer/sdk-web-interfaces';
 import { nanoid } from 'nanoid';
-import { createRouterTransport, createPromiseClient, } from '@connectrpc/connect';
+import { createRouterTransport, createPromiseClient, createContextValues, createContextKey, } from '@connectrpc/connect';
 import { createGrpcWebTransport } from '@connectrpc/connect-web';
 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');
@@ -15,6 +20,11 @@ const getDeviceId = () => {
     localStorage.setItem('sl-device-id', newDeviceId);
     return newDeviceId;
 };
+const getDeviceOs = () => {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    return navigator.userAgentData?.platform || navigator.platform;
+};
 /**
  * transport wrapper, initialize grpc transport, store headers and connect interceptors
  */
@@ -30,25 +40,29 @@ export class Transport {
     streamTransport;
     nanoquery;
     host;
-    interceptors = [];
     $headers;
+    interceptors = [];
     clients;
-    callbackClients;
+    streamClients;
     subscriptions;
     constructor(host) {
         this.host = host;
         this.$headers = new MapStore(createMapStore({
             ['sl-device-id']: getDeviceId(),
+            ['sl-device-os']: getDeviceOs(),
         }), 'transport:headers');
         this.initInterceptors();
         this.clients = new Map();
-        this.callbackClients = new Map();
+        this.streamClients = new Map();
         this.subscriptions = new Map();
-        const [createFetcherStore, createMutatorStore, utils] = nanoquery();
+        const [createFetcherStore, createMutatorStore, utils] = nanoquery({
+            dedupeTime: 1000 * 60 * 5,
+            refetchInterval: 1000 * 60 * 5,
+        });
         this.nanoquery = { createFetcherStore, createMutatorStore, utils };
         this.transport = createGrpcWebTransport({
             baseUrl: host,
-            defaultTimeoutMs: 30000,
+            defaultTimeoutMs: 10000,
             interceptors: this.interceptors,
             useBinaryFormat: true,
         });
@@ -84,7 +98,7 @@ export class Transport {
             this.subscriptions.delete(params);
         }
         this.clients.clear();
-        this.callbackClients.clear();
+        this.streamClients.clear();
         this.subscriptions.clear();
         // ToDo: reset nanoquery instance, basically we should add connect
         // method where setup nanoquery, transports and interceptors, not in constructor
@@ -127,7 +141,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 +181,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/lib/index.d.ts

@@ -12,10 +12,12 @@ declare module '@streamlayer/sdk-web-interfaces' {
     }
     interface StreamLayerContext {
         transport: Transport;
+        analyticsTransport: Transport;
     }
 }
 export declare const transport: (instance: StreamLayerContext, opts: {
     sdkKey: string;
     host: string;
+    analyticsHost: string;
     version?: string;
 }, done: () => void) => void;

package/lib/index.js

@@ -3,8 +3,18 @@ import { Transport } from './grpc/transport';
 export * as queries from './grpc/queries';
 export const transport = (instance, opts, done) => {
     instance.transport = new Transport(opts.host);
+    instance.analyticsTransport = new Transport(opts.analyticsHost);
     instance.sdk.host = instance.transport.host;
     instance.transport.setSdkKey(opts.sdkKey);
     instance.transport.setHeader('sl-sdk-version', opts.version || '-');
+    instance.transport.$headers.subscribe((headers) => {
+        instance.analyticsTransport.$headers.getStore().set(headers);
+    });
+    instance.sdk.onMount(() => {
+        return () => {
+            instance.transport.disconnect();
+            instance.analyticsTransport.disconnect();
+        };
+    });
     done();
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@streamlayer/sdk-web-api",
-  "version": "0.22.0",
+  "version": "0.24.0",
   "type": "module",
   "main": "./lib/index.js",
   "typings": "./lib/index.d.ts",
@@ -21,17 +21,18 @@
     }
   },
   "dependencies": {
-    "@streamlayer/sdk-web-interfaces": "^0.20.5"
+    "@streamlayer/sdk-web-interfaces": "^0.21.0",
+    "@streamlayer/sdk-web-logger": "^0.5.18"
   },
   "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",
-    "@swc/helpers": "^0.5.3",
+    "@nanostores/query": "^0.2.10",
+    "@streamlayer/sl-eslib": "^5.83.1",
+    "@swc/helpers": "~0.5.3",
     "nanoid": "3.3.7",
-    "nanostores": "^0.9.5",
+    "nanostores": "^0.10.0",
     "tslib": "^2.6.2"
   }
 }