@redseat/api 0.3.12 → 0.4.0

package/dist/client.js

@@ -20,6 +20,7 @@ export class RedseatClient {
             'episodes': 'episodes',
             'series': 'series',
             'movies': 'movies',
+            'books': 'books',
             'people': 'people',
             'tags': 'tags',
             'request_processing': 'requestProcessing',
@@ -38,6 +39,11 @@ export class RedseatClient {
     constructor(options) {
         this.disposed = false;
         this.sseReconnectAttempts = 0;
+        this.sseAuthReconnectAttempts = 0;
+        this.sseShouldReconnect = false;
+        this.sseIsConnecting = false;
+        this.sseLifecycleRegistered = false;
+        this.SSE_ACTIVITY_TIMEOUT = 90000; // 90 seconds - reconnect if no data received
         // RxJS subjects for SSE
         this._sseConnectionState = new BehaviorSubject('disconnected');
         this._sseError = new Subject();
@@ -55,6 +61,7 @@ export class RedseatClient {
         this.episodes$ = this.createEventStream('episodes');
         this.series$ = this.createEventStream('series');
         this.movies$ = this.createEventStream('movies');
+        this.books$ = this.createEventStream('books');
         this.people$ = this.createEventStream('people');
         this.tags$ = this.createEventStream('tags');
         this.backups$ = this.createEventStream('backups');
@@ -65,6 +72,62 @@ export class RedseatClient {
         this.watched$ = this.createEventStream('watched');
         this.unwatched$ = this.createEventStream('unwatched');
         this.requestProcessing$ = this.createEventStream('request_processing');
+        // ==================== SSE Methods ====================
+        this.onDocumentVisibilityChange = () => {
+            if (!this.shouldAttemptReconnect() || typeof document === 'undefined') {
+                return;
+            }
+            if (document.visibilityState === 'hidden') {
+                this.sseHiddenAt = Date.now();
+                return;
+            }
+            if (!(this.sseOptions?.reconnectOnPageVisible ?? true)) {
+                return;
+            }
+            const hiddenAt = this.sseHiddenAt;
+            this.sseHiddenAt = undefined;
+            if (hiddenAt === undefined) {
+                return;
+            }
+            const hiddenDuration = Date.now() - hiddenAt;
+            const minHiddenDuration = this.sseOptions?.reconnectVisibleAfterMs ?? 30000;
+            if (hiddenDuration >= minHiddenDuration) {
+                this.forceReconnectSSE();
+            }
+        };
+        this.onWindowPageShow = (event) => {
+            if (!this.shouldAttemptReconnect()) {
+                return;
+            }
+            if (!(this.sseOptions?.reconnectOnPageVisible ?? true)) {
+                return;
+            }
+            if (event.persisted || this.sseConnectionState !== 'connected') {
+                this.forceReconnectSSE();
+            }
+        };
+        this.onWindowOnline = () => {
+            if (!this.shouldAttemptReconnect()) {
+                return;
+            }
+            if (!(this.sseOptions?.reconnectOnOnline ?? true)) {
+                return;
+            }
+            if (this.sseConnectionState !== 'connected') {
+                this.forceReconnectSSE();
+            }
+        };
+        this.onWindowFocus = () => {
+            if (!this.shouldAttemptReconnect()) {
+                return;
+            }
+            if (!(this.sseOptions?.reconnectOnFocus ?? true)) {
+                return;
+            }
+            if (this.sseConnectionState !== 'connected') {
+                this.forceReconnectSSE();
+            }
+        };
         this.server = options.server;
         this.redseatUrl = options.redseatUrl;
         this.getIdToken = options.getIdToken;
@@ -167,7 +230,8 @@ export class RedseatClient {
         }
         this.tokenRefreshPromise = (async () => {
             try {
-                const idToken = await this.getIdToken();
+                // Force refresh the Firebase idToken to ensure it's not stale/cached
+                const idToken = await this.getIdToken(true);
                 // Use fetchServerToken which uses the global axios instance
                 // The token endpoint is on the frontend server, not the backend server
                 const newToken = await fetchServerToken(this.serverId, idToken, this.redseatUrl);
@@ -280,7 +344,52 @@ export class RedseatClient {
         });
         return response.data;
     }
-    // ==================== SSE Methods ====================
+    shouldAttemptReconnect() {
+        return !this.disposed && this.sseShouldReconnect && (this.sseOptions?.autoReconnect ?? true);
+    }
+    clearSSEReconnectTimeout() {
+        if (this.sseReconnectTimeout) {
+            clearTimeout(this.sseReconnectTimeout);
+            this.sseReconnectTimeout = undefined;
+        }
+    }
+    registerSSELifecycleListeners() {
+        if (this.sseLifecycleRegistered || typeof window === 'undefined' || typeof document === 'undefined') {
+            return;
+        }
+        document.addEventListener('visibilitychange', this.onDocumentVisibilityChange);
+        window.addEventListener('pageshow', this.onWindowPageShow);
+        window.addEventListener('online', this.onWindowOnline);
+        window.addEventListener('focus', this.onWindowFocus);
+        this.sseLifecycleRegistered = true;
+        if (document.visibilityState === 'hidden') {
+            this.sseHiddenAt = Date.now();
+        }
+    }
+    unregisterSSELifecycleListeners() {
+        if (!this.sseLifecycleRegistered || typeof window === 'undefined' || typeof document === 'undefined') {
+            return;
+        }
+        document.removeEventListener('visibilitychange', this.onDocumentVisibilityChange);
+        window.removeEventListener('pageshow', this.onWindowPageShow);
+        window.removeEventListener('online', this.onWindowOnline);
+        window.removeEventListener('focus', this.onWindowFocus);
+        this.sseLifecycleRegistered = false;
+        this.sseHiddenAt = undefined;
+    }
+    forceReconnectSSE() {
+        if (!this.shouldAttemptReconnect()) {
+            return;
+        }
+        this.clearSSEReconnectTimeout();
+        if (this.sseAbortController) {
+            this.sseAbortController.abort();
+            this.sseAbortController = undefined;
+        }
+        this.sseReconnectAttempts = 0;
+        this._sseConnectionState.next('reconnecting');
+        void this._connectSSE();
+    }
     /**
      * Connects to the server's SSE endpoint for real-time updates.
      * Automatically manages authentication and reconnection.
@@ -293,23 +402,34 @@ export class RedseatClient {
             autoReconnect: true,
             initialReconnectDelay: 1000,
             maxReconnectDelay: 30000,
+            reconnectOnPageVisible: true,
+            reconnectVisibleAfterMs: 30000,
+            reconnectOnOnline: true,
+            reconnectOnFocus: true,
+            reconnectOnAuthError: true,
+            maxAuthReconnectAttempts: 5,
             ...options
         };
         this.sseReconnectAttempts = 0;
+        this.sseAuthReconnectAttempts = 0;
+        this.sseShouldReconnect = true;
+        this.registerSSELifecycleListeners();
         await this._connectSSE();
     }
     /**
      * Disconnects from the SSE endpoint and cleans up resources.
      */
     disconnectSSE() {
-        if (this.sseReconnectTimeout) {
-            clearTimeout(this.sseReconnectTimeout);
-            this.sseReconnectTimeout = undefined;
-        }
+        this.sseShouldReconnect = false;
+        this.sseIsConnecting = false;
+        this.sseAuthReconnectAttempts = 0;
+        this.clearSSEReconnectTimeout();
+        this.clearActivityTimeout();
         if (this.sseAbortController) {
             this.sseAbortController.abort();
             this.sseAbortController = undefined;
         }
+        this.unregisterSSELifecycleListeners();
         this._sseConnectionState.next('disconnected');
     }
     /**
@@ -335,6 +455,14 @@ export class RedseatClient {
      * Internal method to establish SSE connection
      */
     async _connectSSE() {
+        if (this.disposed || !this.sseShouldReconnect || this.sseIsConnecting) {
+            return;
+        }
+        if (this.sseConnectionState === 'connected' && this.sseAbortController) {
+            return;
+        }
+        this.clearSSEReconnectTimeout();
+        this.sseIsConnecting = true;
         this._sseConnectionState.next('connecting');
         try {
             // Ensure we have a valid token
@@ -343,28 +471,54 @@ export class RedseatClient {
                 throw new Error('No authentication token available');
             }
             const url = this.buildSSEUrl();
-            this.sseAbortController = new AbortController();
+            const abortController = new AbortController();
+            this.sseAbortController = abortController;
             console.log("SSSEEEE URL", url);
-            const response = await fetch(url, {
+            let response = await fetch(url, {
                 method: 'GET',
                 headers: {
                     'Authorization': `Bearer ${this.tokenData.token}`,
                     'Accept': 'text/event-stream',
                     'Cache-Control': 'no-cache'
                 },
-                signal: this.sseAbortController.signal
+                signal: abortController.signal
             });
             if (!response.ok) {
                 if (response.status === 401) {
-                    throw Object.assign(new Error('Authentication failed'), { type: 'auth' });
+                    // Try refreshing token and retry ONCE before giving up
+                    try {
+                        console.log('SSE 401 - attempting token refresh and retry');
+                        await this.refreshToken();
+                        // Retry the connection with the fresh token
+                        const retryResponse = await fetch(url, {
+                            method: 'GET',
+                            headers: {
+                                'Authorization': `Bearer ${this.tokenData.token}`,
+                                'Accept': 'text/event-stream',
+                                'Cache-Control': 'no-cache'
+                            },
+                            signal: this.sseAbortController.signal
+                        });
+                        if (!retryResponse.ok) {
+                            throw Object.assign(new Error('Authentication failed after token refresh'), { type: 'auth' });
+                        }
+                        // Use the retry response instead
+                        response = retryResponse;
+                    }
+                    catch (retryError) {
+                        throw Object.assign(new Error('Authentication failed'), { type: 'auth' });
+                    }
+                }
+                else {
+                    throw Object.assign(new Error(`Server returned ${response.status}`), { type: 'server' });
                 }
-                throw Object.assign(new Error(`Server returned ${response.status}`), { type: 'server' });
             }
             if (!response.body) {
                 throw Object.assign(new Error('No response body'), { type: 'server' });
             }
             this._sseConnectionState.next('connected');
             this.sseReconnectAttempts = 0;
+            this.sseAuthReconnectAttempts = 0;
             // Process the stream in the background (don't await - it runs forever until disconnected)
             this.processSSEStream(response.body).catch(err => {
                 if (err?.name !== 'AbortError') {
@@ -377,8 +531,12 @@ export class RedseatClient {
                 // Intentionally disconnected
                 return;
             }
+            this.sseAbortController = undefined;
             this.handleSSEError(error);
         }
+        finally {
+            this.sseIsConnecting = false;
+        }
     }
     /**
      * Builds the SSE endpoint URL with optional library filters
@@ -392,6 +550,39 @@ export class RedseatClient {
         }
         return url;
     }
+    /**
+     * Resets the activity timeout timer.
+     * Called when data is received from the SSE stream.
+     * If no data is received within the timeout period, triggers reconnection.
+     */
+    resetActivityTimeout() {
+        if (this.sseActivityTimeout) {
+            clearTimeout(this.sseActivityTimeout);
+        }
+        this.sseActivityTimeout = setTimeout(() => {
+            if (this.disposed) {
+                return;
+            }
+            // No activity within timeout period - connection is likely stale
+            console.log('SSE activity timeout - reconnecting');
+            this._sseConnectionState.next('disconnected');
+            // Abort current connection and schedule reconnect
+            if (this.sseAbortController) {
+                this.sseAbortController.abort();
+                this.sseAbortController = undefined;
+            }
+            this.scheduleReconnect();
+        }, this.SSE_ACTIVITY_TIMEOUT);
+    }
+    /**
+     * Clears the activity timeout timer.
+     */
+    clearActivityTimeout() {
+        if (this.sseActivityTimeout) {
+            clearTimeout(this.sseActivityTimeout);
+            this.sseActivityTimeout = undefined;
+        }
+    }
     /**
      * Processes the SSE stream and emits events
      */
@@ -399,15 +590,22 @@ export class RedseatClient {
         const reader = body.getReader();
         const decoder = new TextDecoder();
         let buffer = '';
+        // Start activity timeout tracking
+        this.resetActivityTimeout();
         try {
             while (true) {
                 const { done, value } = await reader.read();
                 if (done) {
                     // Stream ended - server closed connection
+                    this.clearActivityTimeout();
                     this._sseConnectionState.next('disconnected');
-                    this.scheduleReconnect();
+                    if (this.shouldAttemptReconnect()) {
+                        this.scheduleReconnect();
+                    }
                     break;
                 }
+                // Data received - reset activity timeout
+                this.resetActivityTimeout();
                 buffer += decoder.decode(value, { stream: true });
                 const { events, remainingBuffer } = this.parseSSEBuffer(buffer);
                 buffer = remainingBuffer;
@@ -418,12 +616,14 @@ export class RedseatClient {
             }
         }
         catch (error) {
+            this.clearActivityTimeout();
             if (error instanceof Error && error.name === 'AbortError') {
                 return;
             }
             throw error;
         }
         finally {
+            this.sseAbortController = undefined;
             reader.releaseLock();
         }
     }
@@ -497,6 +697,9 @@ export class RedseatClient {
      * Handles SSE errors and triggers reconnection if appropriate
      */
     handleSSEError(error) {
+        if (this.disposed || !this.sseShouldReconnect) {
+            return;
+        }
         const sseError = {
             type: 'network',
             message: error instanceof Error ? error.message : 'Unknown error',
@@ -509,40 +712,68 @@ export class RedseatClient {
         }
         this._sseConnectionState.next('error');
         this._sseError.next(sseError);
-        // Don't reconnect on auth errors
         if (sseError.type === 'auth') {
+            if (!(this.sseOptions?.reconnectOnAuthError ?? true)) {
+                return;
+            }
+            const maxAuthReconnectAttempts = this.sseOptions?.maxAuthReconnectAttempts ?? 5;
+            if (this.sseAuthReconnectAttempts >= maxAuthReconnectAttempts) {
+                return;
+            }
+            this.sseAuthReconnectAttempts++;
+            this.scheduleReconnect();
             return;
         }
+        this.sseAuthReconnectAttempts = 0;
         this.scheduleReconnect();
     }
     /**
      * Schedules a reconnection attempt with exponential backoff
      */
     scheduleReconnect() {
-        if (!this.sseOptions?.autoReconnect) {
+        if (!this.shouldAttemptReconnect()) {
+            return;
+        }
+        const options = this.sseOptions;
+        if (!options) {
             return;
         }
-        if (this.sseOptions.maxReconnectAttempts !== undefined &&
-            this.sseReconnectAttempts >= this.sseOptions.maxReconnectAttempts) {
+        if (options.maxReconnectAttempts !== undefined &&
+            this.sseReconnectAttempts >= options.maxReconnectAttempts) {
             return;
         }
-        const initialDelay = this.sseOptions.initialReconnectDelay ?? 1000;
-        const maxDelay = this.sseOptions.maxReconnectDelay ?? 30000;
+        if (this.sseReconnectTimeout) {
+            return;
+        }
+        const initialDelay = options.initialReconnectDelay ?? 1000;
+        const maxDelay = options.maxReconnectDelay ?? 30000;
         // Exponential backoff with jitter
         const exponentialDelay = initialDelay * Math.pow(2, this.sseReconnectAttempts);
         const jitter = Math.random() * 1000;
         const delay = Math.min(exponentialDelay + jitter, maxDelay);
         this._sseConnectionState.next('reconnecting');
         this.sseReconnectAttempts++;
-        this.sseReconnectTimeout = setTimeout(async () => {
-            // Refresh token before reconnecting
-            try {
-                await this.refreshToken();
-            }
-            catch {
-                // Token refresh failed, will try again on next reconnect
+        this.sseReconnectTimeout = setTimeout(() => {
+            this.sseReconnectTimeout = undefined;
+            if (!this.shouldAttemptReconnect()) {
+                return;
             }
-            this._connectSSE();
+            void (async () => {
+                try {
+                    await this.refreshToken();
+                }
+                catch (error) {
+                    console.log('SSE reconnect: token refresh failed, scheduling another retry', error);
+                    this._sseError.next({
+                        type: 'auth',
+                        message: `Token refresh failed: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                        timestamp: Date.now()
+                    });
+                    this.scheduleReconnect();
+                    return;
+                }
+                await this._connectSSE();
+            })();
         }, delay);
     }
 }

package/dist/interfaces.d.ts

@@ -96,9 +96,6 @@ export interface IFile {
     pages?: number;
     progress?: number;
     lang?: string;
-    tags?: MediaItemReference[];
-    series?: SerieInMedia[];
-    people?: MediaItemReference[];
     faces?: FaceEmbedding[];
     backups?: BackupFile[];
     thumb?: string;
@@ -106,16 +103,73 @@ export interface IFile {
     thumbsize?: number;
     iv?: string;
     origin?: RsLink;
-    movie?: string;
     uploader?: string;
     uploadkey?: string;
     faceRecognitionError?: string;
+    relations?: Relations;
+}
+export interface MediaForUpdate {
+    name?: string;
+    description?: string;
+    mimetype?: string;
+    kind?: FileTypes;
+    size?: number;
+    md5?: string;
+    modified?: number;
+    created?: number;
+    width?: number;
+    height?: number;
+    orientation?: number;
+    colorSpace?: string;
+    icc?: string;
+    mp?: number;
+    vcodecs?: string[];
+    acodecs?: string[];
+    fps?: number;
+    bitrate?: number;
+    focal?: number;
+    iso?: number;
+    model?: string;
+    sspeed?: string;
+    fNumber?: number;
+    pages?: number;
+    duration?: number;
+    progress?: number;
+    addTags?: MediaItemReference[];
+    removeTags?: string[];
+    tagsLookup?: string[];
+    addSeries?: SerieInMedia[];
+    removeSeries?: SerieInMedia[];
+    seriesLookup?: string[];
+    season?: number;
+    episode?: number;
+    addPeople?: MediaItemReference[];
+    removePeople?: string[];
+    peopleLookup?: string[];
+    long?: number;
+    lat?: number;
+    gps?: string;
+    origin?: RsLink;
+    originUrl?: string;
+    ignoreOriginDuplicate?: boolean;
+    movie?: string;
+    book?: string;
+    lang?: string;
+    rating?: number;
+    thumbsize?: number;
+    iv?: string;
+    uploader?: string;
+    uploadkey?: string;
+    uploadId?: string;
+    originalHash?: string;
+    originalId?: string;
 }
 export declare enum LibraryTypes {
     'Photos' = "photos",
     'Shows' = "shows",
     'Movies' = "movies",
-    'IPTV' = "iptv"
+    'IPTV' = "iptv",
+    'Books' = "books"
 }
 export declare enum LibrarySources {
     'Path' = "PathProvider",
@@ -130,13 +184,36 @@ export declare enum LibraryRole {
     share = "share",
     admin = "admin"
 }
+export interface UserMapping {
+    from: string;
+    to: string;
+}
+export interface ServerLibrarySettings {
+    faceThreshold?: number;
+    ignoreGroups?: boolean;
+    preductionModel?: string;
+    mapProgress?: UserMapping[];
+    dataPath?: string;
+}
+export interface ServerLibraryForUpdate {
+    name?: string;
+    source?: LibrarySources;
+    root?: string;
+    settings?: ServerLibrarySettings;
+    credentials?: string;
+    plugin?: string;
+}
 export interface ILibrary {
     id?: string;
     name: string;
     type: LibraryTypes;
     source?: LibrarySources;
+    root?: string;
     roles?: LibraryRole[];
     crypt?: boolean;
+    settings: ServerLibrarySettings;
+    credentials?: string;
+    plugin?: string;
     hidden?: boolean;
     status?: string;
 }
@@ -152,6 +229,7 @@ export interface ITag {
     alt?: string[];
     thumb?: string;
     params?: any;
+    otherids?: string[];
 }
 export declare enum LinkType {
     'profile' = "profile",
@@ -186,6 +264,7 @@ export interface IPerson {
     tmdb?: number;
     trakt?: number;
     socials?: RsLink[];
+    otherids?: string[];
     gender?: Gender;
     country?: string;
     bio?: string;
@@ -207,7 +286,7 @@ export interface ISerie {
     tmdb?: number;
     trakt?: number;
     tvdb?: number;
-    otherids?: string;
+    otherids?: string[];
     imdbRating?: number;
     imdbVotes?: number;
     traktRating?: number;
@@ -287,6 +366,32 @@ export interface IMovie {
     backgroundv: number;
     cardv: number;
 }
+export interface IBook {
+    id: string;
+    name: string;
+    kind?: string;
+    serieRef?: string;
+    volume?: number;
+    chapter?: number;
+    year?: number;
+    airdate?: number;
+    overview?: string;
+    pages?: number;
+    params?: any;
+    lang?: string;
+    original?: string;
+    isbn13?: string;
+    openlibraryEditionId?: string;
+    openlibraryWorkId?: string;
+    googleBooksVolumeId?: string;
+    asin?: string;
+    modified: number;
+    added: number;
+    posterv?: number;
+    backgroundv?: number;
+    cardv?: number;
+}
+export type BookSort = 'modified' | 'added' | 'name' | 'year';
 export interface IServer {
     id: string;
     name?: string;
@@ -338,8 +443,58 @@ export interface IBackupFile {
     error?: string;
 }
 export interface ExternalImage {
-    url: string;
-    type: string;
+    type?: string;
+    url: RsRequest;
+    aspectRatio?: number;
+    height?: number;
+    lang?: string;
+    voteAverage?: number;
+    voteCount?: number;
+    width?: number;
+}
+export interface Relations {
+    peopleDetails?: IPerson[];
+    tagsDetails?: ITag[];
+    people?: MediaItemReference[];
+    tags?: MediaItemReference[];
+    series?: SerieInMedia[];
+    seriesDetails?: ISerie[];
+    movies?: string[];
+    moviesDetails?: IMovie[];
+    books?: string[];
+    booksDetails?: IBook[];
+    extImages?: ExternalImage[];
+}
+export type ItemWithRelations<T> = T & {
+    relations?: Relations;
+};
+export interface SearchRelations {
+    peopleDetails?: IPerson[];
+    tagsDetails?: ITag[];
+    people?: MediaItemReference[];
+    tags?: MediaItemReference[];
+    extImages?: ExternalImage[];
+}
+export interface SearchStreamResultBase {
+    relations?: SearchRelations;
+    images?: ExternalImage[];
+}
+export type SearchStreamResult<K extends string, T> = SearchStreamResultBase & {
+    metadata?: Partial<Record<K, T>>;
+};
+export type SearchResult<K extends string, T> = SearchStreamResult<K, T>;
+export type BookSearchResult = SearchResult<'book', IBook>;
+export type MovieSearchResult = SearchResult<'movie', IMovie>;
+export type SerieSearchResult = SearchResult<'serie', ISerie>;
+export type BookSearchStreamResult = SearchStreamResult<'book', IBook>;
+export type MovieSearchStreamResult = SearchStreamResult<'movie', IMovie>;
+export type SerieSearchStreamResult = SearchStreamResult<'serie', ISerie>;
+export type LookupSearchStreamResult = SearchStreamResult<'book' | 'movie' | 'serie', IBook | IMovie | ISerie>;
+export type GroupedSearchStreamPayload<T> = Record<string, T[]>;
+export interface SearchStreamCallbacks<T> {
+    onResults?: (results: GroupedSearchStreamPayload<T>) => void;
+    onFinished?: () => void;
+    onError?: (error: unknown) => void;
 }
 export interface IChannel {
     id: string;
@@ -748,6 +903,8 @@ export interface RsRequest {
     albums?: string[];
     season?: number;
     episode?: number;
+    movie?: string;
+    book?: SerieInMedia;
     language?: string;
     resolution?: string;
     videoFormat?: string;
@@ -769,6 +926,7 @@ export interface RsGroupDownload {
     groupFilename?: string;
     groupMime?: string;
     requests: RsRequest[];
+    infos?: MediaForUpdate;
 }
 /**
  * Request processing status from plugin-based download/processing.