@maestro_io/maestro-web-sdk 4.0.0 → 4.0.2

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

@@ -0,0 +1,457 @@
+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);
+    }
+    /**
+     * 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';
+        }
+        // Check cache if using GET and cache is enabled
+        if (method === HttpMethod.GET && useCache) {
+            const cacheKey = this.cacheManager.produceCacheKey(JSON.stringify({
+                endpoint,
+                params,
+                data: null,
+            }));
+            const cachedData = this.cacheManager.getCache(cacheKey);
+            if (cachedData) {
+                return cachedData;
+            }
+        }
+        try {
+            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`);
+            }
+            // Handle empty response if needed
+            if (skipResponseBodyDeserialization && !response) {
+                response = {};
+            }
+            // Cache the response for GET requests
+            if (method === HttpMethod.GET && useCache) {
+                const cacheKey = this.cacheManager.produceCacheKey(JSON.stringify({
+                    endpoint,
+                    params,
+                    data: null,
+                }));
+                this.cacheManager.setCache(cacheKey, response);
+            }
+            return response;
+        }
+        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, }) {
+        // Check cache if using GET and cache is enabled
+        if (method === HttpMethod.GET && useCache) {
+            const cacheKey = this.cacheManager.produceCacheKey(JSON.stringify({
+                endpoint,
+                params,
+                data: null,
+            }));
+            const cachedData = this.cacheManager.getCache(cacheKey);
+            if (cachedData) {
+                return cachedData;
+            }
+        }
+        try {
+            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`);
+            }
+            // Handle empty response if needed
+            if (skipResponseBodyDeserialization && !response) {
+                response = {};
+            }
+            // Cache the response for GET requests
+            if (method === HttpMethod.GET && useCache) {
+                const cacheKey = this.cacheManager.produceCacheKey(JSON.stringify({
+                    endpoint,
+                    params,
+                    data: null,
+                }));
+                this.cacheManager.setCache(cacheKey, response);
+            }
+            return response;
+        }
+        catch (error) {
+            return this.handleError(error);
+        }
+    }
+    /**
+     * Make a request to an external API and return both data and headers
+     */
+    async externalApiRequestWithHeaders({ endpoint, method = HttpMethod.GET, params = {}, data = null, headers = {}, useCache = false, skipResponseBodyDeserialization = false, }) {
+        // Check cache if using GET and cache is enabled
+        if (method === HttpMethod.GET && useCache) {
+            const cacheKey = this.cacheManager.produceCacheKey(JSON.stringify({
+                endpoint,
+                params,
+                data: null,
+            }));
+            const cachedData = this.cacheManager.getCache(cacheKey);
+            if (cachedData) {
+                // Return cached data with empty headers since we don't cache headers
+                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`);
+            }
+            // Handle empty response if needed
+            if (skipResponseBodyDeserialization && !response.data) {
+                response.data = {};
+            }
+            // Cache the response data for GET requests (headers are not cached)
+            if (method === HttpMethod.GET && useCache) {
+                const cacheKey = this.cacheManager.produceCacheKey(JSON.stringify({
+                    endpoint,
+                    params,
+                    data: null,
+                }));
+                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/NetworkManagerFactory.d.ts

@@ -0,0 +1,42 @@
+import NetworkManager, { NetworkManagerOptions } from './NetworkManager';
+import { ServiceType, ServiceNetworkManagerConfig, IStatsNetworkManager, IBetsNetworkManager, IMaestroNetworkManager, NetworkManagerFactoryConfig } from './types';
+/**
+ * Service-specific NetworkManager that includes metadata about its service type
+ */
+declare class ServiceNetworkManager extends NetworkManager {
+    readonly serviceType: ServiceType;
+    readonly externalBaseURL: string;
+    constructor(serviceType: ServiceType, externalBaseURL: string, options?: NetworkManagerOptions, localStorageOverride?: Storage);
+}
+/**
+ * Factory for creating service-specific NetworkManager instances
+ * This replaces the singleton pattern with a factory pattern
+ */
+export declare class NetworkManagerFactory {
+    private static defaultConfig;
+    /**
+     * Configure factory defaults
+     */
+    static configure(config: NetworkManagerFactoryConfig): void;
+    /**
+     * Create a Stats service NetworkManager
+     */
+    static createStatsNetworkManager(externalBaseURL: string, options?: Partial<NetworkManagerOptions>): IStatsNetworkManager;
+    /**
+     * Create a Bets service NetworkManager
+     */
+    static createBetsNetworkManager(externalBaseURL: string, options?: Partial<NetworkManagerOptions>): IBetsNetworkManager;
+    /**
+     * Create a Maestro service NetworkManager
+     */
+    static createMaestroNetworkManager(options?: Partial<NetworkManagerOptions>): IMaestroNetworkManager;
+    /**
+     * Create a NetworkManager for any service type
+     */
+    static createForService(config: ServiceNetworkManagerConfig, options?: Partial<NetworkManagerOptions>): ServiceNetworkManager;
+    /**
+     * Reset factory to defaults (useful for testing)
+     */
+    static reset(): void;
+}
+export default NetworkManagerFactory;

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

@@ -0,0 +1,101 @@
+import NetworkManager from './NetworkManager';
+import { ServiceType, } from './types';
+/**
+ * Service-specific NetworkManager that includes metadata about its service type
+ */
+class ServiceNetworkManager extends NetworkManager {
+    constructor(serviceType, externalBaseURL, options = {}, localStorageOverride) {
+        super(options, localStorageOverride);
+        Object.defineProperty(this, "serviceType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "externalBaseURL", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.serviceType = serviceType;
+        this.externalBaseURL = externalBaseURL;
+    }
+}
+/**
+ * Factory for creating service-specific NetworkManager instances
+ * This replaces the singleton pattern with a factory pattern
+ */
+export class NetworkManagerFactory {
+    /**
+     * Configure factory defaults
+     */
+    static configure(config) {
+        this.defaultConfig = { ...this.defaultConfig, ...config };
+    }
+    /**
+     * Create a Stats service NetworkManager
+     */
+    static createStatsNetworkManager(externalBaseURL, options = {}) {
+        const networkManagerOptions = {
+            defaultCacheDuration: this.defaultConfig.defaultCacheDuration,
+            externalBaseURL,
+            ...options,
+        };
+        return new ServiceNetworkManager(ServiceType.STATS, externalBaseURL, networkManagerOptions, undefined // Keep localStorage default
+        );
+    }
+    /**
+     * Create a Bets service NetworkManager
+     */
+    static createBetsNetworkManager(externalBaseURL, options = {}) {
+        const networkManagerOptions = {
+            defaultCacheDuration: this.defaultConfig.defaultCacheDuration,
+            externalBaseURL,
+            ...options,
+        };
+        return new ServiceNetworkManager(ServiceType.BETS, externalBaseURL, networkManagerOptions, undefined // Keep localStorage default
+        );
+    }
+    /**
+     * Create a Maestro service NetworkManager
+     */
+    static createMaestroNetworkManager(options = {}) {
+        const networkManagerOptions = {
+            defaultCacheDuration: this.defaultConfig.defaultCacheDuration,
+            ...options,
+        };
+        return new ServiceNetworkManager(ServiceType.MAESTRO, '', // Maestro doesn't use external base URL
+        networkManagerOptions, undefined // Keep localStorage default
+        );
+    }
+    /**
+     * Create a NetworkManager for any service type
+     */
+    static createForService(config, options = {}) {
+        const networkManagerOptions = {
+            defaultCacheDuration: config.defaultCacheDuration || this.defaultConfig.defaultCacheDuration,
+            externalBaseURL: config.externalBaseURL,
+            ...options,
+        };
+        return new ServiceNetworkManager(config.serviceType, config.externalBaseURL, networkManagerOptions, undefined // Keep localStorage default
+        );
+    }
+    /**
+     * Reset factory to defaults (useful for testing)
+     */
+    static reset() {
+        this.defaultConfig = {
+            defaultCacheDuration: 60000,
+        };
+    }
+}
+Object.defineProperty(NetworkManagerFactory, "defaultConfig", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: {
+        defaultCacheDuration: 60000, // 1 minute
+    }
+});
+export default NetworkManagerFactory;

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);
+}

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

@@ -0,0 +1,45 @@
+// Network error types
+export class NetworkError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'NetworkError';
+    }
+}
+export class AuthError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'AuthError';
+    }
+}
+export class NotFoundError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'NotFoundError';
+    }
+}
+export class ServerError extends Error {
+    constructor(statusCode, message) {
+        super(message);
+        Object.defineProperty(this, "statusCode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = 'ServerError';
+        this.statusCode = statusCode;
+    }
+}
+export class BadRequestError extends Error {
+    constructor(statusCode, message) {
+        super(message);
+        Object.defineProperty(this, "statusCode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = 'BadRequestError';
+        this.statusCode = statusCode;
+    }
+}