@maestro_io/maestro-web-sdk 5.0.0 → 5.1.1

package/dist/src/services/InsightsService/InsightsService.js

@@ -0,0 +1,74 @@
+import AxiosNetworkClient from '@/external/AxiosNetworkClient';
+import { captureException } from '@/sentry';
+import SDK from '@/index';
+const INSIGHTS_BASE_URL = 'https://insights.maestro.io';
+export default class InsightsService {
+    constructor() {
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.client = new AxiosNetworkClient({
+            baseURL: INSIGHTS_BASE_URL,
+            backoff: 2,
+            delay: 1000,
+            retries: 1,
+        });
+    }
+    isEnabled() {
+        const globalConfig = SDK.getGlobalConfig();
+        const analyticsEnabled = globalConfig?.bbd?.analytics?.enabled ?? true;
+        return analyticsEnabled;
+    }
+    async action(payload) {
+        if (!this.isEnabled()) {
+            console.warn('InsightsService: Analytics is disabled in global config');
+            return;
+        }
+        try {
+            // do like qs.stringify with my payload and send as formData
+            const parsedData = new URLSearchParams();
+            for (const [key, value] of Object.entries(payload)) {
+                if (value !== undefined && value !== null) {
+                    parsedData.append(key, value.toString());
+                }
+            }
+            await this.client.post('/action', parsedData, undefined, {
+                'Content-Type': 'application/x-www-form-urlencoded',
+            });
+        }
+        catch (err) {
+            captureException(err, { payload });
+            console.error('Failed to send insights action:', err);
+        }
+    }
+    async getServerTime() {
+        if (!this.isEnabled()) {
+            return {
+                time: Date.now(),
+                diff: 0,
+            };
+        }
+        const responseStart = Date.now();
+        try {
+            return await this.client.get('/time', {
+                _: `${Date.now()}-${this.randomId()}`,
+                client_time: responseStart,
+            });
+        }
+        catch (err) {
+            captureException(err);
+            console.error('Failed to get server time:', err);
+            return {
+                time: Date.now(),
+                diff: 0,
+            };
+        }
+    }
+    randomId() {
+        return (Math.random().toString(36).substring(2, 15) +
+            Math.random().toString(36).substring(2, 15));
+    }
+}

package/dist/src/services/NetworkManager/NetworkManager.d.ts

@@ -0,0 +1,153 @@
+import { ICacheManager } from '../../external/ports/cacheManager';
+import { INetworkClient } from '../../external/ports/networkClient';
+export declare const MAESTRO_BASE_URL = "https://api.maestro.io";
+export declare const SDK_FLAVOR = "MaestroKit_Web";
+export declare const ENDPOINTS: {
+    CAN_I_PLAY: string;
+    STREAM: string;
+    USER_PROFILE: string;
+    ACTIVE_USER: string;
+};
+export declare const HttpMethod: {
+    readonly GET: "GET";
+    readonly POST: "POST";
+    readonly PUT: "PUT";
+    readonly DELETE: "DELETE";
+};
+export type HttpMethod = typeof HttpMethod[keyof typeof HttpMethod];
+export interface NetworkManagerOptions {
+    networkClient?: INetworkClient;
+    externalNetworkClient?: INetworkClient;
+    externalBaseURL?: string;
+    cacheManager?: ICacheManager;
+    defaultCacheDuration?: number;
+}
+declare class NetworkManager {
+    private cacheManager;
+    private maestroClient;
+    private externalClient;
+    private pollingTasks;
+    private localStorage;
+    constructor(options?: NetworkManagerOptions, localStorageOverride?: Storage);
+    /**
+     * Set authentication for Maestro APIs
+     */
+    setAuthentication(token: string | null, apiKey: string | null): void;
+    /**
+     * Execute a request with optional caching
+     * Extracts duplicated cache logic from request methods
+     */
+    private withCache;
+    /**
+     * Handle errors from network requests
+     */
+    private handleError;
+    /**
+     * Make a request to the Maestro API
+     */
+    maestroApiRequest<T = any>({ endpoint, method, params, data, headers, useCache, maestroDefaultHeaders, skipResponseBodyDeserialization, }: {
+        endpoint: string;
+        method?: HttpMethod;
+        params?: Record<string, any>;
+        data?: any;
+        headers?: Record<string, string>;
+        useCache?: boolean;
+        maestroDefaultHeaders?: {
+            siteId: string;
+            jwt: string;
+        } | null;
+        skipResponseBodyDeserialization?: boolean;
+    }): Promise<T>;
+    /**
+     * Make a request to an external API
+     */
+    externalApiRequest<T = any>({ endpoint, method, params, data, headers, useCache, skipResponseBodyDeserialization, }: {
+        endpoint: string;
+        method?: HttpMethod;
+        params?: Record<string, any>;
+        data?: any;
+        headers?: Record<string, string>;
+        useCache?: boolean;
+        skipResponseBodyDeserialization?: boolean;
+    }): Promise<T>;
+    /**
+     * Make a request to an external API and return both data and headers
+     * Note: Only data is cached, headers are not persisted
+     */
+    externalApiRequestWithHeaders<T = any>({ endpoint, method, params, data, headers, useCache, skipResponseBodyDeserialization, }: {
+        endpoint: string;
+        method?: HttpMethod;
+        params?: Record<string, any>;
+        data?: any;
+        headers?: Record<string, string>;
+        useCache?: boolean;
+        skipResponseBodyDeserialization?: boolean;
+    }): Promise<{
+        data: T;
+        headers: Record<string, string>;
+    }>;
+    /**
+     * Start polling a Maestro API endpoint at specified interval
+     */
+    pollMaestroApiRequest<T = any>({ endpoint, interval, method, params, data, headers, maestroDefaultHeaders, skipResponseBodyDeserialization, onData, onError, }: {
+        endpoint: string;
+        interval: number;
+        method?: HttpMethod;
+        params?: Record<string, any>;
+        data?: any;
+        headers?: Record<string, string>;
+        maestroDefaultHeaders?: {
+            siteId: string;
+            jwt: string;
+        } | null;
+        skipResponseBodyDeserialization?: boolean;
+        onData: (data: T) => void;
+        onError?: (error: Error) => void;
+    }): {
+        stop: () => void;
+    };
+    /**
+     * Start polling an external API endpoint at specified interval
+     */
+    pollExternalApiRequest<T = any>({ endpoint, interval, method, params, data, headers, skipResponseBodyDeserialization, onData, onError, }: {
+        endpoint: string;
+        interval: number;
+        method?: HttpMethod;
+        params?: Record<string, any>;
+        data?: any;
+        headers?: Record<string, string>;
+        skipResponseBodyDeserialization?: boolean;
+        onData: (data: T) => void;
+        onError?: (error: Error) => void;
+    }): {
+        stop: () => void;
+    };
+    /**
+     * Start polling an external API endpoint at specified interval and return both data and headers
+     */
+    pollExternalApiRequestWithHeaders<T = any>({ endpoint, interval, method, params, data, headers, skipResponseBodyDeserialization, onData, onError, }: {
+        endpoint: string;
+        interval: number;
+        method?: HttpMethod;
+        params?: Record<string, any>;
+        data?: any;
+        headers?: Record<string, string>;
+        skipResponseBodyDeserialization?: boolean;
+        onData: (data: {
+            data: T;
+            headers: Record<string, string>;
+        }) => void;
+        onError?: (error: Error) => void;
+    }): {
+        stop: () => void;
+    };
+    /**
+     * Stop all polling tasks
+     */
+    stopAllPolling(): void;
+    /**
+     * Clear all cached data
+     */
+    clearAllCache(): void;
+}
+export default NetworkManager;

package/dist/src/services/NetworkManager/NetworkManager.js

@@ -0,0 +1,434 @@
+import AxiosNetworkClient from '../../external/AxiosNetworkClient';
+import LocalStorageCacheManager from '../../external/LocalStorageCacheManager';
+import { AuthError, BadRequestError, NetworkError, NotFoundError, ServerError, } from './errors';
+export const MAESTRO_BASE_URL = 'https://api.maestro.io';
+export const SDK_FLAVOR = 'MaestroKit_Web';
+// Common endpoints
+export const ENDPOINTS = {
+    CAN_I_PLAY: '/caniplay/v1',
+    STREAM: '/stream/v1',
+    USER_PROFILE: '/userprofile/v1',
+    ACTIVE_USER: '/active/v2',
+    // Add more endpoints as needed
+};
+// HTTP methods
+export const HttpMethod = {
+    GET: 'GET',
+    POST: 'POST',
+    PUT: 'PUT',
+    DELETE: 'DELETE',
+};
+class NetworkManager {
+    constructor(options = {}, localStorageOverride) {
+        Object.defineProperty(this, "cacheManager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "maestroClient", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "externalClient", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "pollingTasks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "localStorage", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.pollingTasks = new Map();
+        // Initialize cache manager
+        this.cacheManager =
+            options.cacheManager ||
+                new LocalStorageCacheManager(options.defaultCacheDuration);
+        // Initialize Maestro API client
+        this.maestroClient =
+            options.networkClient ||
+                new AxiosNetworkClient({
+                    baseURL: MAESTRO_BASE_URL,
+                    retries: 3,
+                    delay: 1000,
+                    backoff: 2,
+                });
+        // Initialize External API client
+        this.externalClient =
+            options.externalNetworkClient ||
+                new AxiosNetworkClient({
+                    baseURL: options.externalBaseURL || '',
+                    retries: 3,
+                    delay: 1000,
+                    backoff: 2,
+                });
+        this.localStorage = localStorageOverride ||
+            (typeof globalThis !== 'undefined' && globalThis.localStorage) || {
+            length: 0,
+            clear: () => { },
+            getItem: () => null,
+            key: () => null,
+            removeItem: () => { },
+            setItem: () => { },
+        };
+    }
+    /**
+     * Set authentication for Maestro APIs
+     */
+    setAuthentication(token, apiKey) {
+        this.maestroClient.setAuthentication(token, apiKey);
+    }
+    /**
+     * Execute a request with optional caching
+     * Extracts duplicated cache logic from request methods
+     */
+    async withCache(cacheParams, useCache, fetchFn) {
+        const cacheKey = this.cacheManager.produceCacheKey(JSON.stringify({
+            endpoint: cacheParams.endpoint,
+            params: cacheParams.params,
+            data: null,
+        }));
+        if (useCache) {
+            const cachedData = this.cacheManager.getCache(cacheKey);
+            if (cachedData) {
+                return cachedData;
+            }
+        }
+        const response = await fetchFn();
+        if (useCache) {
+            this.cacheManager.setCache(cacheKey, response);
+        }
+        return response;
+    }
+    /**
+     * Handle errors from network requests
+     */
+    handleError(error) {
+        // Check if it's an Axios error with a response
+        if (error.response) {
+            const status = error.response.status;
+            const message = error.response.data?.message || error.message;
+            if (status === 401 || status === 403) {
+                throw new AuthError(message);
+            }
+            else if (status === 404) {
+                throw new NotFoundError(message);
+            }
+            else if (status >= 500) {
+                throw new ServerError(status, message);
+            }
+            else {
+                throw new BadRequestError(status, message);
+            }
+        }
+        else if (error.request) {
+            // Request was made but no response received
+            throw new NetworkError('Network request failed');
+        }
+        else {
+            // Something else happened while setting up the request
+            throw error;
+        }
+    }
+    /**
+     * Make a request to the Maestro API
+     */
+    async maestroApiRequest({ endpoint, method = HttpMethod.GET, params = {}, data = null, headers = {}, useCache = false, maestroDefaultHeaders = null, skipResponseBodyDeserialization = false, }) {
+        // Add SDK flavor to headers
+        const requestHeaders = {
+            'x-maestro-maestro-kit-flavor': SDK_FLAVOR,
+            ...headers,
+        };
+        // Add Maestro default headers if provided
+        if (maestroDefaultHeaders) {
+            requestHeaders['x-maestro-client-id'] = maestroDefaultHeaders.siteId;
+            requestHeaders['Authorization'] = `Bearer ${maestroDefaultHeaders.jwt}`;
+            requestHeaders['Content-type'] = 'application/json';
+        }
+        const shouldCache = method === HttpMethod.GET && useCache;
+        const fetchFn = async () => {
+            let response;
+            if (method === HttpMethod.GET) {
+                response = await this.maestroClient.get(endpoint, params, requestHeaders);
+            }
+            else if (method === HttpMethod.POST) {
+                response = await this.maestroClient.post(endpoint, data);
+            }
+            else {
+                throw new Error(`Method ${method} not implemented`);
+            }
+            if (skipResponseBodyDeserialization && !response) {
+                response = {};
+            }
+            return response;
+        };
+        try {
+            return await this.withCache({ endpoint, params }, shouldCache, fetchFn);
+        }
+        catch (error) {
+            return this.handleError(error);
+        }
+    }
+    /**
+     * Make a request to an external API
+     */
+    async externalApiRequest({ endpoint, method = HttpMethod.GET, params = {}, data = null, headers = {}, useCache = false, skipResponseBodyDeserialization = false, }) {
+        const shouldCache = method === HttpMethod.GET && useCache;
+        const fetchFn = async () => {
+            let response;
+            if (method === HttpMethod.GET) {
+                response = await this.externalClient.get(endpoint, params, headers);
+            }
+            else if (method === HttpMethod.POST) {
+                response = await this.externalClient.post(endpoint, data);
+            }
+            else {
+                throw new Error(`Method ${method} not implemented`);
+            }
+            if (skipResponseBodyDeserialization && !response) {
+                response = {};
+            }
+            return response;
+        };
+        try {
+            return await this.withCache({ endpoint, params }, shouldCache, fetchFn);
+        }
+        catch (error) {
+            return this.handleError(error);
+        }
+    }
+    /**
+     * Make a request to an external API and return both data and headers
+     * Note: Only data is cached, headers are not persisted
+     */
+    async externalApiRequestWithHeaders({ endpoint, method = HttpMethod.GET, params = {}, data = null, headers = {}, useCache = false, skipResponseBodyDeserialization = false, }) {
+        const shouldCache = method === HttpMethod.GET && useCache;
+        const cacheKey = this.cacheManager.produceCacheKey(JSON.stringify({ endpoint, params, data: null }));
+        // Check cache - return cached data with empty headers
+        if (shouldCache) {
+            const cachedData = this.cacheManager.getCache(cacheKey);
+            if (cachedData) {
+                return { data: cachedData, headers: {} };
+            }
+        }
+        try {
+            let response;
+            if (method === HttpMethod.GET) {
+                response = await this.externalClient.getWithHeaders(endpoint, params, headers);
+            }
+            else if (method === HttpMethod.POST) {
+                response = await this.externalClient.postWithHeaders(endpoint, data, params, headers);
+            }
+            else {
+                throw new Error(`Method ${method} not implemented`);
+            }
+            if (skipResponseBodyDeserialization && !response.data) {
+                response.data = {};
+            }
+            // Cache only data, not headers
+            if (shouldCache) {
+                this.cacheManager.setCache(cacheKey, response.data);
+            }
+            return response;
+        }
+        catch (error) {
+            return this.handleError(error);
+        }
+    }
+    /**
+     * Start polling a Maestro API endpoint at specified interval
+     */
+    pollMaestroApiRequest({ endpoint, interval, method = HttpMethod.GET, params = {}, data = null, headers = {}, maestroDefaultHeaders = null, skipResponseBodyDeserialization = false, onData, onError, }) {
+        // Create a unique key for this polling task
+        const taskKey = `${endpoint}-${JSON.stringify(params)}-${JSON.stringify(data)}`;
+        // Stop existing polling for this endpoint if it exists
+        if (this.pollingTasks.has(taskKey)) {
+            this.pollingTasks.get(taskKey)?.controller.abort();
+            this.pollingTasks.delete(taskKey);
+        }
+        // Create a new abort controller for cancellation
+        const controller = new AbortController();
+        const signal = controller.signal;
+        // Start the polling
+        (async () => {
+            while (!signal.aborted) {
+                try {
+                    const response = await this.maestroApiRequest({
+                        endpoint,
+                        method,
+                        params,
+                        data,
+                        headers,
+                        maestroDefaultHeaders,
+                        skipResponseBodyDeserialization,
+                        useCache: false, // Don't use cache for polling
+                    });
+                    // Call the callback with the data
+                    onData(response);
+                }
+                catch (error) {
+                    // Call the error callback if provided
+                    if (onError) {
+                        onError(error);
+                    }
+                }
+                // Wait for the interval before next poll
+                if (!signal.aborted) {
+                    await new Promise((resolve) => setTimeout(resolve, interval));
+                }
+            }
+        })();
+        // Store the controller for later cancellation
+        this.pollingTasks.set(taskKey, { controller, interval });
+        // Return a function to stop polling
+        return {
+            stop: () => {
+                if (this.pollingTasks.has(taskKey)) {
+                    this.pollingTasks.get(taskKey)?.controller.abort();
+                    this.pollingTasks.delete(taskKey);
+                }
+            },
+        };
+    }
+    /**
+     * Start polling an external API endpoint at specified interval
+     */
+    pollExternalApiRequest({ endpoint, interval, method = HttpMethod.GET, params = {}, data = null, headers = {}, skipResponseBodyDeserialization = false, onData, onError, }) {
+        // Create a unique key for this polling task
+        const taskKey = `external-${endpoint}-${JSON.stringify(params)}-${JSON.stringify(data)}`;
+        // Stop existing polling for this endpoint if it exists
+        if (this.pollingTasks.has(taskKey)) {
+            this.pollingTasks.get(taskKey)?.controller.abort();
+            this.pollingTasks.delete(taskKey);
+        }
+        // Create a new abort controller for cancellation
+        const controller = new AbortController();
+        const signal = controller.signal;
+        // Start the polling
+        (async () => {
+            while (!signal.aborted) {
+                try {
+                    const response = await this.externalApiRequest({
+                        endpoint,
+                        method,
+                        params,
+                        data,
+                        headers,
+                        skipResponseBodyDeserialization,
+                        useCache: false, // Don't use cache for polling
+                    });
+                    // Call the callback with the data
+                    onData(response);
+                }
+                catch (error) {
+                    // Call the error callback if provided
+                    if (onError) {
+                        onError(error);
+                    }
+                }
+                // Wait for the interval before next poll
+                if (!signal.aborted) {
+                    await new Promise((resolve) => setTimeout(resolve, interval));
+                }
+            }
+        })();
+        // Store the controller for later cancellation
+        this.pollingTasks.set(taskKey, { controller, interval });
+        // Return a function to stop polling
+        return {
+            stop: () => {
+                if (this.pollingTasks.has(taskKey)) {
+                    this.pollingTasks.get(taskKey)?.controller.abort();
+                    this.pollingTasks.delete(taskKey);
+                }
+            },
+        };
+    }
+    /**
+     * Start polling an external API endpoint at specified interval and return both data and headers
+     */
+    pollExternalApiRequestWithHeaders({ endpoint, interval, method = HttpMethod.GET, params = {}, data = null, headers = {}, skipResponseBodyDeserialization = false, onData, onError, }) {
+        // Create a unique key for this polling task
+        const taskKey = `external-headers-${endpoint}-${JSON.stringify(params)}-${JSON.stringify(data)}`;
+        // Stop existing polling for this endpoint if it exists
+        if (this.pollingTasks.has(taskKey)) {
+            this.pollingTasks.get(taskKey)?.controller.abort();
+            this.pollingTasks.delete(taskKey);
+        }
+        // Create a new abort controller for cancellation
+        const controller = new AbortController();
+        const signal = controller.signal;
+        // Start the polling
+        (async () => {
+            while (!signal.aborted) {
+                try {
+                    const response = await this.externalApiRequestWithHeaders({
+                        endpoint,
+                        method,
+                        params,
+                        data,
+                        headers,
+                        skipResponseBodyDeserialization,
+                        useCache: false, // Don't use cache for polling
+                    });
+                    // Call the callback with both data and headers
+                    onData(response);
+                }
+                catch (error) {
+                    // Call the error callback if provided
+                    if (onError) {
+                        onError(error);
+                    }
+                }
+                // Wait for the interval before next poll
+                if (!signal.aborted) {
+                    await new Promise((resolve) => setTimeout(resolve, interval));
+                }
+            }
+        })();
+        // Store the controller for later cancellation
+        this.pollingTasks.set(taskKey, { controller, interval });
+        // Return a function to stop polling
+        return {
+            stop: () => {
+                if (this.pollingTasks.has(taskKey)) {
+                    this.pollingTasks.get(taskKey)?.controller.abort();
+                    this.pollingTasks.delete(taskKey);
+                }
+            },
+        };
+    }
+    /**
+     * Stop all polling tasks
+     */
+    stopAllPolling() {
+        for (const [key, { controller }] of this.pollingTasks.entries()) {
+            controller.abort();
+            this.pollingTasks.delete(key);
+        }
+    }
+    /**
+     * Clear all cached data
+     */
+    clearAllCache() {
+        const originalLength = this.localStorage.length;
+        for (let i = 0; i < originalLength; i++) {
+            const key = this.localStorage.key(i);
+            if (key && key.startsWith('maestro-cache-')) {
+                this.localStorage.removeItem(key);
+            }
+        }
+    }
+}
+export default NetworkManager;

package/dist/src/services/NetworkManager/errors.d.ts

@@ -0,0 +1,17 @@
+export declare class NetworkError extends Error {
+    constructor(message: string);
+}
+export declare class AuthError extends Error {
+    constructor(message: string);
+}
+export declare class NotFoundError extends Error {
+    constructor(message: string);
+}
+export declare class ServerError extends Error {
+    statusCode: number;
+    constructor(statusCode: number, message: string);
+}
+export declare class BadRequestError extends Error {
+    statusCode: number;
+    constructor(statusCode: number, message: string);
+}