@streamlayer/sdk-web-api 0.0.1

package/README.md

@@ -0,0 +1,6 @@
+# core-api
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+Run `nx build core-api` to build the library.

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

@@ -0,0 +1,5 @@
+import { ReadableAtom } from 'nanostores';
+import type { StreamSettings } from '@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb';
+import { Transport } from '../transport';
+export declare const $retrieveEventId: ($providerStreamId: ReadableAtom<string | undefined>, transport: Transport) => import("@nanostores/query").FetcherStore<string | undefined, any>;
+export declare const $streamSettings: (slStreamId: ReadableAtom<string | undefined>, transport: Transport) => import("@nanostores/query").FetcherStore<StreamSettings | undefined, any>;

package/lib/grpc/queries/event.js

@@ -0,0 +1,38 @@
+import { Events } from '@streamlayer/sl-eslib/sports/events/events_connect';
+import { Client } from '@streamlayer/sl-eslib/sdkSettings/client/client_connect';
+export const $retrieveEventId = ($providerStreamId, transport) => {
+    const { client, queryKey } = transport.createPromiseClient(Events, {
+        method: 'retrieveEventId',
+        params: [$providerStreamId],
+    });
+    return transport.nanoquery.createFetcherStore(queryKey, {
+        fetcher: async (_, __, id) => {
+            if (!id || typeof id !== 'string') {
+                return '';
+            }
+            try {
+                const res = await client.retrieveEventId({
+                    id,
+                });
+                return res.data?.id || '';
+            }
+            catch (err) {
+                return '';
+            }
+        },
+    });
+};
+export const $streamSettings = (slStreamId, transport) => {
+    const { client, queryKey } = transport.createPromiseClient(Client, { method: 'getStream', params: [slStreamId] });
+    return transport.nanoquery.createFetcherStore(queryKey, {
+        fetcher: async (_, __, id) => {
+            if (!id) {
+                return undefined;
+            }
+            const res = await client.getStream({
+                id: id, // we are sure that id is a string
+            });
+            return res.data?.attributes;
+        },
+    });
+};

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

@@ -0,0 +1,3 @@
+export * from './event';
+export * from './organization';
+export * from './user';

package/lib/grpc/queries/index.js

@@ -0,0 +1,3 @@
+export * from './event';
+export * from './organization';
+export * from './user';

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

@@ -0,0 +1,21 @@
+import { ReadableAtom } from 'nanostores';
+import { Transport } from '../transport';
+export { $user } from './user';
+export declare const $organizationSettings: ($enabled: ReadableAtom<'on' | undefined>, transport: Transport) => import("@nanostores/query").FetcherStore<{
+    id: string;
+    overlays?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").SdkOverlay[] | undefined;
+    buttonIcon?: string | undefined;
+    tinodeHost?: string | undefined;
+    audience?: string | undefined;
+    name?: string | undefined;
+    provider?: string | undefined;
+    primaryColor?: string | undefined;
+    secondaryColor?: string | undefined;
+    moderationPrimaryColor?: string | undefined;
+    linkShareIcon?: string | undefined;
+    linkShareText?: string | undefined;
+    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;
+} | 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/organization.js

@@ -0,0 +1,28 @@
+import { Client } from '@streamlayer/sl-eslib/sdkSettings/client/client_connect';
+export { $user } from './user';
+export const $organizationSettings = ($enabled, transport) => {
+    const { client, queryKey } = transport.createPromiseClient(Client, { method: 'getOrganization', params: [$enabled] });
+    return transport.nanoquery.createFetcherStore(queryKey, {
+        fetcher: async () => {
+            const res = await client.getOrganization({});
+            return res.data
+                ? {
+                    ...res.data.attributes,
+                    id: res.data.id,
+                }
+                : undefined;
+        },
+    });
+};
+export const $organizationAdvertising = ($enabled, transport) => {
+    const { client, queryKey } = transport.createPromiseClient(Client, {
+        method: 'getOrganizationAdvertising',
+        params: [$enabled],
+    });
+    return transport.nanoquery.createFetcherStore(queryKey, {
+        fetcher: async () => {
+            const res = await client.getOrganizationAdvertising({});
+            return res.data?.attributes;
+        },
+    });
+};

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

@@ -0,0 +1,13 @@
+import { ReadableAtom } from 'nanostores';
+import type { BypassAuthRequest, BypassAuthResponse } from '@streamlayer/sl-eslib/users/users_pb';
+import { PlainMessage } from '@bufbuild/protobuf';
+import { Transport } from '../transport';
+export declare const $user: ($userToken: ReadableAtom<string | undefined>, transport: Transport) => import("@nanostores/query").FetcherStore<import("@streamlayer/sl-eslib/users/users_pb").MeResponse, any>;
+export declare const $bypassLogin: (transport: Transport) => import("@nanostores/query").MutatorStore<PlainMessage<BypassAuthRequest>, PlainMessage<BypassAuthResponse>, any>;
+export declare const bypassAuth: (transport: Transport, params: {
+    userKey?: string;
+    schema?: string;
+    init?: boolean;
+}) => Promise<BypassAuthResponse>;
+export declare const $userSettings: ($userToken: ReadableAtom<string | undefined>, transport: Transport) => import("@nanostores/query").FetcherStore<import("@streamlayer/sl-eslib/sdkSettings/client/client_pb").ClientSettings | undefined, any>;
+export declare const register: (transport: Transport, phone: string) => Promise<import("@streamlayer/sl-eslib/users/users_pb").RegisterResponse>;

package/lib/grpc/queries/user.js

@@ -0,0 +1,41 @@
+import { Users } from '@streamlayer/sl-eslib/users/users_connect';
+import { Client } from '@streamlayer/sl-eslib/sdkSettings/client/client_connect';
+// user query
+// cache user
+// invalidate token
+// login
+// save token
+// called on update user key
+export const $user = ($userToken, transport) => {
+    const { queryKey, client } = transport.createPromiseClient(Users, { method: 'me', params: [$userToken] });
+    return transport.nanoquery.createFetcherStore(queryKey, {
+        fetcher: () => client.me({}),
+    });
+};
+export const $bypassLogin = (transport) => {
+    const { client, queryKeyStr } = transport.createPromiseClient(Users, { method: 'bypassAuth' });
+    return transport.nanoquery.createMutatorStore(async ({ data: { userKey, schema, init }, getCacheUpdater }) => {
+        const [updateCache] = getCacheUpdater(queryKeyStr);
+        const user = await client.bypassAuth({ userKey, schema, init });
+        updateCache(user);
+        return user;
+    });
+};
+export const bypassAuth = (transport, params) => {
+    const { client } = transport.createPromiseClient(Users, { method: 'bypassAuth' });
+    return client.bypassAuth(params);
+};
+export const $userSettings = ($userToken, // sl user token
+transport) => {
+    const { client, queryKey } = transport.createPromiseClient(Client, { method: 'get', params: [$userToken] });
+    return transport.nanoquery.createFetcherStore(queryKey, {
+        fetcher: async () => {
+            const data = await client.get({});
+            return data.data?.attributes;
+        },
+    });
+};
+export const register = (transport, phone) => {
+    const { client } = transport.createPromiseClient(Users, { method: 'register' });
+    return client.register({ id: phone });
+};

package/lib/grpc/subscription.d.ts

@@ -0,0 +1,43 @@
+import { CallbackClient } from '@connectrpc/connect';
+import { Atom } from 'nanostores';
+import type { ServiceType, Message, PlainMessage, MethodInfoServerStreaming } from '@bufbuild/protobuf';
+import { Transport } from './transport';
+type StreamMethods<T extends ServiceType> = {
+    [P in keyof CallbackClient<T> as T['methods'][P] extends MethodInfoServerStreaming<any, any> ? P : never]: P;
+};
+export type StreamMethod<T extends ServiceType> = StreamMethods<T>[keyof StreamMethods<T>] extends keyof CallbackClient<T> ? StreamMethods<T>[keyof StreamMethods<T>] : never;
+declare enum ServerStreamSubscriptionStatus {
+    Init = "init",
+    Ready = "ready",
+    Connecting = "connecting",
+    Connected = "connected",
+    Disconnected = "disconnected",
+    Failed = "failed",
+    Reconnecting = "reconnecting"
+}
+export type ServerStreamSubscriptionOptions = {
+    name: string;
+    withStore?: boolean;
+};
+export declare class ServerStreamSubscription<T extends ServiceType, Request extends Message<Request>, Response extends Message<Response>, M extends StreamMethod<T> = StreamMethod<T>, Method extends CallbackClient<T>[M] = CallbackClient<T>[M]> {
+    params: Atom<PlainMessage<Request>> | PlainMessage<Request>;
+    private stream?;
+    private method;
+    private name;
+    private headers;
+    private listeners;
+    private state;
+    private store?;
+    constructor(headers: Transport['$headers'], method: Method, params: Atom<PlainMessage<Request>> | PlainMessage<Request>, options: ServerStreamSubscriptionOptions);
+    updateState: (status: ServerStreamSubscriptionStatus) => void;
+    addStateLog: (msg: string) => void;
+    addListener: (name: string, listener: (response: Response) => void) => boolean;
+    removeListener: (name: string) => void;
+    connect: () => void;
+    disconnect: () => void;
+    reconnect: () => void;
+    getStore: () => import("nanostores").WritableAtom<Response | null | undefined> | undefined;
+    private onData;
+    private onStreamError;
+}
+export {};

package/lib/grpc/subscription.js

@@ -0,0 +1,114 @@
+import { MapStore, SingleStore, createMapStore, createSingleStore } from '@streamlayer/sdk-web-interfaces';
+import { Code } from '@connectrpc/connect';
+var ServerStreamSubscriptionStatus;
+(function (ServerStreamSubscriptionStatus) {
+    ServerStreamSubscriptionStatus["Init"] = "init";
+    ServerStreamSubscriptionStatus["Ready"] = "ready";
+    ServerStreamSubscriptionStatus["Connecting"] = "connecting";
+    ServerStreamSubscriptionStatus["Connected"] = "connected";
+    ServerStreamSubscriptionStatus["Disconnected"] = "disconnected";
+    ServerStreamSubscriptionStatus["Failed"] = "failed";
+    ServerStreamSubscriptionStatus["Reconnecting"] = "reconnecting";
+})(ServerStreamSubscriptionStatus || (ServerStreamSubscriptionStatus = {}));
+export class ServerStreamSubscription {
+    params;
+    stream;
+    method;
+    name;
+    headers;
+    listeners;
+    state;
+    store;
+    constructor(headers, method, params, options) {
+        const initState = {
+            status: ServerStreamSubscriptionStatus.Init,
+            ts: new Date(),
+            log: [],
+        };
+        this.state = new MapStore(createMapStore(initState), `subscription:${options.name}:state`);
+        this.name = options.name;
+        this.headers = headers;
+        this.listeners = new Map();
+        this.params = params;
+        this.method = method;
+        if (options.withStore) {
+            this.store = new SingleStore(createSingleStore(null), `subscription:${options.name}:store`);
+        }
+        if ('subscribe' in params && typeof params.subscribe === 'function') {
+            params.subscribe(() => {
+                this.reconnect();
+            });
+        }
+        this.updateState(ServerStreamSubscriptionStatus.Ready);
+    }
+    updateState = (status) => {
+        this.state.setValue('status', status);
+        this.state.setValue('ts', new Date());
+        this.addStateLog(`status => ${status}`);
+    };
+    addStateLog = (msg) => {
+        const log = this.state.getStore().get()['log'];
+        this.state.setValue('log', [...log, `${new Date().toLocaleString()}: ${msg}`]);
+    };
+    addListener = (name, listener) => {
+        if (this.listeners.has(name)) {
+            this.addStateLog(`listener '${name}' not added`);
+            return false;
+        }
+        this.listeners.set(name, listener);
+        this.addStateLog(`listener '${name}' added`);
+        return true;
+    };
+    removeListener = (name) => {
+        this.listeners.delete(name);
+        this.addStateLog(`listener '${name}' removed`);
+    };
+    connect = () => {
+        this.updateState(ServerStreamSubscriptionStatus.Connecting);
+        if (this.stream) {
+            this.addStateLog(`disconnect prev connection`);
+            this.stream();
+        }
+        const params = 'get' in this.params && typeof this.params.get === 'function' ? this.params.get() : this.params;
+        this.stream = this.method(params, 
+        // ToDo: fix types
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        this.onData, this.onStreamError, { headers: this.headers.getValues() });
+        this.updateState(ServerStreamSubscriptionStatus.Connected);
+    };
+    disconnect = () => {
+        if (this.stream) {
+            this.stream();
+        }
+        this.listeners.clear();
+        this.updateState(ServerStreamSubscriptionStatus.Disconnected);
+    };
+    reconnect = () => {
+        this.updateState(ServerStreamSubscriptionStatus.Reconnecting);
+        this.connect();
+    };
+    getStore = () => this.store?.getStore();
+    onData = (response) => {
+        this.addStateLog(`received data => ${JSON.stringify(response)}`);
+        if (this.store) {
+            this.store.setValue(response);
+        }
+        for (const [, listener] of this.listeners) {
+            listener(response);
+        }
+        this.addStateLog(`data routed to ${this.listeners.size} listeners`);
+    };
+    onStreamError = (error) => {
+        if (error === undefined) {
+            return;
+        }
+        if (error.code !== Code.Canceled && error.rawMessage !== '[canceled] BodyStreamBuffer was aborted') {
+            this.updateState(ServerStreamSubscriptionStatus.Failed);
+            this.state.setValue('error', error);
+        }
+        else {
+            this.disconnect();
+        }
+    };
+}

package/lib/grpc/transport.d.ts

@@ -0,0 +1,75 @@
+import { createRouterTransport, ConnectRouter, Interceptor, PromiseClient, CallbackClient, 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 { Atom } from 'nanostores';
+import { ServerStreamSubscription, type ServerStreamSubscriptionOptions } from './subscription';
+type KnownHeaders = {
+    authorization?: string;
+    sdk?: string;
+    'sl-device-id': string;
+} & Record<string, string>;
+export type GrpcTransport = Transport['transport'];
+type ReservedHeaders = 'sdk' | 'authorization';
+type ExcludeReservedHeaders<T> = ReservedHeaders extends T ? never : T extends ReservedHeaders ? never : T;
+declare global {
+    interface Window {
+        __GRPC_DEVTOOLS_EXTENSION__?: () => import('@connectrpc/connect').Interceptor;
+    }
+}
+type NanoqueryReturnType = ReturnType<typeof nanoquery>;
+type NanoqueryObjectType = {
+    createFetcherStore: NanoqueryReturnType[0];
+    createMutatorStore: NanoqueryReturnType[1];
+    utils: NanoqueryReturnType[2];
+};
+/**
+ * transport wrapper, initialize grpc transport, store headers and connect interceptors
+ */
+export declare class Transport {
+    toJsonOptions: {
+        emitDefaultValues: boolean;
+        enumAsInteger: boolean;
+        useProtoFieldName: boolean;
+    };
+    readonly transport: ReturnType<typeof createGrpcWebTransport>;
+    readonly nanoquery: NanoqueryObjectType;
+    readonly host: string;
+    protected interceptors: Interceptor[];
+    private readonly $headers;
+    private clients;
+    private callbackClients;
+    private subscriptions;
+    constructor(host: string);
+    addSubscription: <T extends ServiceType, Req extends Message<Req>, Res extends Message<Res>>(method: CallbackClient<T>[import("./subscription").StreamMethod<T>], 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, import("./subscription").StreamMethod<T>, CallbackClient<T>[import("./subscription").StreamMethod<T>]>;
+    removeSubscription: (subscription: ServerStreamSubscription<ServiceType, Message, Message>) => void;
+    disconnect: () => void;
+    registerInterceptor: (interceptor: Interceptor) => void;
+    removeInterceptor: (interceptor: Interceptor) => void;
+    getClient: <T extends ServiceType>(service: T) => PromiseClient<T>;
+    getCallbackClient: <T extends ServiceType>(service: T) => CallbackClient<T>;
+    createPromiseClient: <T extends ServiceType>(service: T, { params, method }: {
+        params?: KeyInput | undefined;
+        method: keyof T["methods"];
+    }) => {
+        client: PromiseClient<T>;
+        queryKey: ((string | number | true) | import("nanostores").ReadableAtom<(string | number | true) | (false | void | null | undefined)> | import("@nanostores/query").FetcherStore<any, any>)[];
+        queryKeyStr: string;
+    };
+    createCallbackClient: <T extends ServiceType>(service: T) => {
+        client: CallbackClient<T>;
+    };
+    setSdkKey: (sdkKey: string) => void;
+    setAuth: (token?: string) => void;
+    setHeader: <T extends string = string>(name: ExcludeReservedHeaders<T>, value: string) => void;
+    getHeader: (name: keyof KnownHeaders) => string;
+    getHeaders: () => KnownHeaders;
+    initInterceptors: () => void;
+}
+export declare class MockTransport extends Transport {
+    transport: ReturnType<typeof createRouterTransport>;
+    calls: Array<UnaryRequest | StreamRequest>;
+    constructor(transport: (router: ConnectRouter) => void);
+}
+export {};

package/lib/grpc/transport.js

@@ -0,0 +1,160 @@
+import { MapStore, createMapStore } from '@streamlayer/sdk-web-interfaces';
+import { createRouterTransport, createPromiseClient, createCallbackClient, } 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';
+/**
+ * transport wrapper, initialize grpc transport, store headers and connect interceptors
+ */
+export class Transport {
+    toJsonOptions = {
+        emitDefaultValues: false,
+        enumAsInteger: true,
+        useProtoFieldName: false,
+    };
+    transport;
+    nanoquery;
+    host;
+    interceptors = [];
+    $headers;
+    clients;
+    callbackClients;
+    subscriptions;
+    constructor(host) {
+        this.host = host;
+        this.$headers = new MapStore(createMapStore({
+            ['sl-device-id']: process?.env?.NX_DEVICE_ID || 'sdk-web-dev',
+        }), 'transport:headers');
+        this.initInterceptors();
+        this.clients = new Map();
+        this.callbackClients = new Map();
+        this.subscriptions = new Map();
+        const [createFetcherStore, createMutatorStore, utils] = nanoquery();
+        this.nanoquery = { createFetcherStore, createMutatorStore, utils };
+        this.transport = createGrpcWebTransport({
+            baseUrl: host,
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            interceptors: this.interceptors,
+            useBinaryFormat: true,
+        });
+    }
+    // use shared request params, based on Atom, each new Atom will create new subscription
+    // mutate Atom, subscription automatically reconnect  with new params
+    // if headers changed, reconnect subscription with new headers automatically
+    addSubscription = (method, params, options) => {
+        const currentSubscription = this.subscriptions.get(params);
+        if (currentSubscription) {
+            return currentSubscription;
+        }
+        const subscription = new ServerStreamSubscription(this.$headers, method, params, options);
+        // ToDo: fix types
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        this.subscriptions.set(params, subscription);
+        return subscription;
+    };
+    removeSubscription = (subscription) => {
+        subscription.disconnect();
+        this.subscriptions.delete(subscription.params);
+    };
+    // cleanup subscriptions
+    disconnect = () => {
+        for (const [name, subscription] of this.subscriptions) {
+            subscription.disconnect();
+            this.subscriptions.delete(name);
+        }
+    };
+    registerInterceptor = (interceptor) => {
+        this.interceptors.push(interceptor);
+    };
+    removeInterceptor = (interceptor) => {
+        this.interceptors = this.interceptors.filter((i) => i !== interceptor);
+    };
+    getClient = (service) => {
+        const serviceName = service.typeName;
+        if (this.clients.has(serviceName)) {
+            return this.clients.get(serviceName);
+        }
+        const client = createPromiseClient(service, this.transport);
+        this.clients.set(serviceName, client);
+        return client;
+    };
+    getCallbackClient = (service) => {
+        const serviceName = service.typeName;
+        if (this.callbackClients.has(serviceName)) {
+            return this.callbackClients.get(serviceName);
+        }
+        const client = createCallbackClient(service, this.transport);
+        this.callbackClients.set(serviceName, client);
+        return client;
+    };
+    // create unary client, used for query request
+    createPromiseClient = (service, { params = [], method }) => {
+        const client = this.getClient(service);
+        const methodName = service.methods[method].name;
+        const queryKey = [
+            service.typeName,
+            methodName.charAt(0).toLowerCase() + methodName.slice(1),
+            ...(Array.isArray(params) ? params : [params]),
+        ];
+        const queryKeyWithoutParams = [service.typeName, methodName.charAt(0).toLowerCase() + methodName.slice(1)];
+        return { client, queryKey, queryKeyStr: queryKeyWithoutParams.join('') };
+    };
+    // create callback client, used for server stream subscriptions
+    createCallbackClient = (service) => {
+        const client = this.getCallbackClient(service);
+        return { client };
+    };
+    setSdkKey = (sdkKey) => {
+        this.$headers.setValue('sdk', sdkKey);
+    };
+    setAuth = (token) => {
+        this.$headers.setValue('authorization', token);
+    };
+    setHeader = (name, value) => this.$headers.setValue(name, value);
+    getHeader = (name) => this.$headers.getValue(name);
+    getHeaders = () => this.$headers.getValues();
+    initInterceptors = () => {
+        if (this.interceptors.length !== 0) {
+            return;
+        }
+        const auth = (next) => (req) => {
+            const headers = this.$headers.getValues();
+            for (const header in headers) {
+                req.header.set(header, headers[header]);
+            }
+            return next(req);
+        };
+        this.interceptors.push(auth);
+        if (process.env.NODE_ENV !== 'test') {
+            this.interceptors.push(__GRPC_DEVTOOLS_EXTENSION__());
+        }
+        // if (window.__GRPC_DEVTOOLS_EXTENSION__) {
+        //   this.interceptors.push(window.__GRPC_DEVTOOLS_EXTENSION__())
+        // } else {
+        //   window.addEventListener('grpc_devtools_loaded', () => {
+        //     if (window.__GRPC_DEVTOOLS_EXTENSION__) {
+        //       this.interceptors.push(window.__GRPC_DEVTOOLS_EXTENSION__())
+        //     }
+        //   })
+        // }
+    };
+}
+export class MockTransport extends Transport {
+    calls;
+    constructor(transport) {
+        super(process.env.NX_GRPC_HOST || 'https://grpc-web.next.streamlayer.io:443');
+        this.calls = [];
+        this.interceptors.push((next) => (req) => {
+            this.calls.push(req);
+            return next(req);
+        });
+        this.transport = createRouterTransport(transport, {
+            transport: {
+                interceptors: this.interceptors,
+            },
+        });
+    }
+}

package/lib/index.d.ts

@@ -0,0 +1,20 @@
+import { StreamLayerContext } from '@streamlayer/sdk-web-interfaces';
+import { FetcherStore } from '@nanostores/query';
+export type { ServerStreamSubscriptionOptions } from './grpc/subscription';
+export { Transport } from './grpc/transport';
+import { Transport } from './grpc/transport';
+export type { GrpcTransport } from './grpc/transport';
+export * as queries from './grpc/queries';
+export type GetApiResponseType<T extends (...args: any[]) => FetcherStore> = ReturnType<ReturnType<T>['get']>['data'];
+declare module '@streamlayer/sdk-web-interfaces' {
+    interface StreamLayerSDK {
+        host: string;
+    }
+    interface StreamLayerContext {
+        transport: Transport;
+    }
+}
+export declare const transport: (instance: StreamLayerContext, opts: {
+    sdkKey: string;
+    host: string;
+}, done: () => void) => void;

package/lib/index.js

@@ -0,0 +1,9 @@
+export { Transport } from './grpc/transport';
+import { Transport } from './grpc/transport';
+export * as queries from './grpc/queries';
+export const transport = (instance, opts, done) => {
+    instance.transport = new Transport(opts.host);
+    instance.sdk.host = instance.transport.host;
+    instance.transport.setSdkKey(opts.sdkKey);
+    done();
+};

package/lib/utils/devtools.d.ts

@@ -0,0 +1 @@
+export declare const __GRPC_DEVTOOLS_EXTENSION__: any;

package/lib/utils/devtools.js

@@ -0,0 +1,65 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+async function* logEach(store, stream) {
+    for await (const m of stream) {
+        store.response.message = m;
+        store.received_at = Date.now();
+        const msg = {
+            type: '__GRPC_DEVTOOLS_EXTENSION__',
+            data: store,
+        };
+        window.postMessage(msg);
+        yield m;
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const __GRPC_DEVTOOLS_EXTENSION__ = () => (next) => async (request) => {
+    const store = {
+        name: request.url,
+        request: {},
+        response: {},
+    };
+    store.request.header = Object.fromEntries(request.header.entries());
+    store.sent_at = Date.now();
+    try {
+        const response = await next(request);
+        store.received_at = Date.now();
+        store.stream = response.stream;
+        store.response.header = Object.fromEntries(response.header.entries());
+        store.response.trailer = Object.fromEntries(response.trailer.entries());
+        if (!response.stream) {
+            store.request.message = request.message;
+            store.response.message = response.message;
+            store.latency = store.received_at - store.sent_at;
+            const msg = {
+                type: '__GRPC_DEVTOOLS_EXTENSION__',
+                data: store,
+            };
+            window.postMessage(msg);
+        }
+        else {
+            return {
+                ...response,
+                message: logEach(store, response.message),
+            };
+        }
+        return response;
+    }
+    catch (e) {
+        store.received_at = Date.now();
+        store.request.message = request.message;
+        store.response.trailer = {
+            ['grpc-status']: e.code,
+            ['grpc-message']: e.rawMessage,
+        };
+        store.response.message = e.rawMessage;
+        store.latency = store.received_at - store.sent_at;
+        const msg = {
+            type: '__GRPC_DEVTOOLS_EXTENSION__',
+            data: store,
+        };
+        window.postMessage(msg);
+        throw e;
+    }
+};
+window.dispatchEvent(new CustomEvent('grpc_devtools_loaded'));

package/lib/utils/grpc-stub.d.ts

@@ -0,0 +1,7 @@
+import { Transport } from '..';
+export declare class GrpcStub {
+    readonly transport: Transport;
+    private stubs;
+    constructor();
+    stub: (method: string, response: Record<string, unknown>) => void;
+}

package/lib/utils/grpc-stub.js

@@ -0,0 +1,23 @@
+import { Transport } from '..';
+export class GrpcStub {
+    transport;
+    stubs;
+    constructor() {
+        this.transport = new Transport(process.env.NX_GRPC_HOST || 'https://grpc-web.next.streamlayer.io:443');
+        this.stubs = new Map();
+        const stubbedUnary = (service, method, signal, timeoutMs, header, input) => {
+            const key = `${service.typeName}${method.name}`.toLowerCase();
+            console.log('grpc unary', { key, input });
+            for (const [stubKey, stubValue] of this.stubs) {
+                if (stubKey === key) {
+                    return { message: stubValue };
+                }
+            }
+            throw new Error(JSON.stringify({ message: 'not stubbed correctly', service, method, signal, timeoutMs, header, input }));
+        };
+        this.transport.transport.unary = stubbedUnary;
+    }
+    stub = (method, response) => {
+        this.stubs.set(method.toLowerCase(), response);
+    };
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@streamlayer/sdk-web-api",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "./lib/index.js",
+  "typings": "./lib/index.d.ts",
+  "files": [
+    "lib/",
+    "package.json"
+  ],
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "import": "./lib/index.js",
+      "default": "./lib/index.js"
+    },
+    "./queries/*": {
+      "types": "./lib/grpc/queries/*.d.ts",
+      "import": "./lib/grpc/queries/*.js",
+      "default": "./lib/grpc/queries/*.js"
+    }
+  },
+  "dependencies": {
+    "@streamlayer/sdk-web-interfaces": "^0.17.3"
+  },
+  "devDependencies": {
+    "@swc/helpers": "~0.5.3",
+    "@bufbuild/protobuf": "^1.4.2",
+    "@connectrpc/connect": "^1.1.3",
+    "@connectrpc/connect-web": "^1.1.3",
+    "@nanostores/query": "^0.2.8",
+    "@streamlayer/sl-eslib": "^5.45.1",
+    "nanostores": "^0.9.4",
+    "tslib": "^2.6.2"
+  }
+}