@maestro_io/maestro-web-sdk 5.2.0 → 5.2.2

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

@@ -1,74 +0,0 @@
-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

@@ -1,153 +0,0 @@
-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

@@ -1,434 +0,0 @@
-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(status, message, error.response.data);
-            }
-            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

@@ -1,19 +0,0 @@
-export declare class NetworkError extends Error {
-    constructor(message: string);
-}
-export declare class AuthError extends Error {
-    statusCode: number;
-    data?: unknown;
-    constructor(statusCode: number, message: string, data?: unknown);
-}
-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);
-}