refactor(bookmarks): update BookmarkProvider references to use IBookm…

…arkProvider interface

.changeset/unlucky-drinks-cheat.md

@@ -0,0 +1,9 @@
+---
+'@equinor/fusion-framework-module-bookmark': minor
+---
+
+- Exposed the `IBookmarkProvider` interface and updated references.
+- Improved handling of the parent provider in `BookmarkProvider`.
+- Fixed `BookmarkProvider.on` to only emit when the source of the event is the provider.
+- Refactored `BookmarkProvider.generatePayload` to better handle the creation and update of bookmark payloads.
+- Ensured all observable executions to the API are terminated after the first successful or failed response.

packages/modules/bookmark/src/BookmarkConfigurator.ts

@@ -15,6 +15,7 @@ import { BookmarkClient } from './BookmarkClient';
 import type { BookmarkModule } from './bookmark-module';
 import { bookmarkConfigSchema } from './bookmark-config.schema';
 import type { BookmarkModuleConfig } from './types';
+import { BookmarkProvider } from './BookmarkProvider';
 
 const initialBookmarkConfig = bookmarkConfigSchema
     .pick({
@@ -199,7 +200,10 @@ export class BookmarkModuleConfigurator extends BaseConfigBuilder<BookmarkModule
             const parentModules = init.ref as ModulesInstanceType<[BookmarkModule]>;
             if (parentModules && 'bookmark' in parentModules) {
                 const parent = parentModules.bookmark;
-                if ('version' in parent && parent.version.satisfies('>=2.0.0')) {
+                if (
+                    'version' in parent &&
+                    (parent as unknown as BookmarkProvider).version.satisfies('>=2.0.0')
+                ) {
                     this._set('parent', async () => parent);
                 } else {
                     this.#log?.warn('invalid version of parent BookmarkProvider provided');

packages/modules/bookmark/src/BookmarkProvider.events.ts

@@ -1,86 +1,86 @@
 import type { FrameworkEventInit, IFrameworkEvent } from '@equinor/fusion-framework-module-event';
 import type { Bookmark } from './types';
-import type { BookmarkPayloadGenerator, BookmarkProvider } from './BookmarkProvider';
-import { BookmarkNew, BookmarkUpdate } from './BookmarkClient.interface';
+import type { BookmarkPayloadGenerator, IBookmarkProvider } from './BookmarkProvider.interface';
+import type { BookmarkNew, BookmarkUpdate } from './BookmarkClient.interface';
 
 export interface BookmarkProviderEventMap {
     /**
      * An event that is emitted before current bookmark is changed.
      */
     onCurrentBookmarkChange: IFrameworkEvent<
-        FrameworkEventInit<{ current?: Bookmark | null; next: Bookmark | null }, BookmarkProvider>
+        FrameworkEventInit<{ current?: Bookmark | null; next: Bookmark | null }, IBookmarkProvider>
     >;
 
     /**
      * An event that is emitted when the current bookmark has changed.
      */
     onCurrentBookmarkChanged: IFrameworkEvent<
-        FrameworkEventInit<Bookmark | null, BookmarkProvider>
+        FrameworkEventInit<Bookmark | null | undefined, IBookmarkProvider>
     >;
 
     /**
      * An event that is emitted before a bookmark is created.
      */
-    onBookmarkCreate: IFrameworkEvent<FrameworkEventInit<BookmarkNew, BookmarkProvider>>;
+    onBookmarkCreate: IFrameworkEvent<FrameworkEventInit<BookmarkNew, IBookmarkProvider>>;
 
     /**
      * An event that is emitted when a bookmark has been created.
      */
-    onBookmarkCreated: IFrameworkEvent<FrameworkEventInit<Bookmark, BookmarkProvider>>;
+    onBookmarkCreated: IFrameworkEvent<FrameworkEventInit<Bookmark, IBookmarkProvider>>;
 
     /**
      * An event that is emitted before a bookmark is updated.
      */
     onBookmarkUpdate: IFrameworkEvent<
-        FrameworkEventInit<{ current?: Bookmark; updates: BookmarkUpdate }, BookmarkProvider>
+        FrameworkEventInit<{ current?: Bookmark; updates: BookmarkUpdate }, IBookmarkProvider>
     >;
 
     /**
      * An event that is emitted before a bookmark is updated.
      */
-    onBookmarkUpdated: IFrameworkEvent<FrameworkEventInit<Bookmark, BookmarkProvider>>;
+    onBookmarkUpdated: IFrameworkEvent<FrameworkEventInit<Bookmark, IBookmarkProvider>>;
 
     /**
      * An event that is emitted before a bookmark is removed.
      */
-    onBookmarkDelete: IFrameworkEvent<FrameworkEventInit<{ id: string }, BookmarkProvider>>;
+    onBookmarkDelete: IFrameworkEvent<FrameworkEventInit<{ id: string }, IBookmarkProvider>>;
 
     /**
      * An event that is emitted before a bookmark is removed.
      */
-    onBookmarkDeleted: IFrameworkEvent<FrameworkEventInit<{ id: string }, BookmarkProvider>>;
+    onBookmarkDeleted: IFrameworkEvent<FrameworkEventInit<{ id: string }, IBookmarkProvider>>;
 
     /**
      * An event that is emitted before a bookmark is added to the user's favorites.
      */
     onBookmarkFavouriteRemove: IFrameworkEvent<
-        FrameworkEventInit<{ id: string }, BookmarkProvider>
+        FrameworkEventInit<{ id: string }, IBookmarkProvider>
     >;
 
     /**
      * An event that is emitted when a bookmark is removed from the user's favorites.
      */
     onBookmarkFavouriteRemoved: IFrameworkEvent<
-        FrameworkEventInit<{ id: string }, BookmarkProvider>
+        FrameworkEventInit<{ id: string }, IBookmarkProvider>
     >;
 
     /**
      * An event that is emitted before a bookmark is added to the user's favorites.
      */
-    onBookmarkFavouriteAdd: IFrameworkEvent<FrameworkEventInit<{ id: string }, BookmarkProvider>>;
+    onBookmarkFavouriteAdd: IFrameworkEvent<FrameworkEventInit<{ id: string }, IBookmarkProvider>>;
 
     /**
      * An event that is emitted when a bookmark is added to the user's favorites.
      */
     onBookmarkFavouriteAdded: IFrameworkEvent<
-        FrameworkEventInit<Bookmark | undefined, BookmarkProvider>
+        FrameworkEventInit<Bookmark | undefined, IBookmarkProvider>
     >;
 
     /**
      * An event that is emitted when a new bookmark payload generator is added.
      */
     onBookmarkPayloadCreatorAdded: IFrameworkEvent<
-        FrameworkEventInit<BookmarkPayloadGenerator, BookmarkProvider>
+        FrameworkEventInit<BookmarkPayloadGenerator, IBookmarkProvider>
     >;
 }
 

packages/modules/bookmark/src/BookmarkProvider.interface.ts

@@ -0,0 +1,142 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Observable, ObservableInput } from 'rxjs';
+import type { Bookmark, BookmarkData, BookmarkWithoutData } from './types';
+import { BookmarkNew, BookmarkUpdate } from './BookmarkClient.interface';
+import { BookmarkProviderEventMap } from './BookmarkProvider.events';
+import { BookmarkState } from './BookmarkProvider.store';
+
+export type BookmarkCreateArgs<T extends BookmarkData = any> = Omit<
+    BookmarkNew<T>,
+    'appKey' | 'contextId' | 'sourceSystem'
+> &
+    Partial<Pick<BookmarkNew<T>, 'appKey'>>;
+
+export type BookmarkUpdateOptions = {
+    excludePayloadGeneration?: boolean;
+};
+
+export type BookmarkPayloadGenerator<TData extends BookmarkData = any> = (
+    payload?: Partial<TData> | null,
+    initial?: Partial<TData> | null,
+) => Promise<Partial<TData> | void> | Partial<TData> | void;
+
+/**
+ * Interface representing a Bookmark Provider.
+ */
+export interface IBookmarkProvider {
+    readonly currentBookmark: Bookmark | null | undefined;
+    /**
+     * Observable of the current bookmark.
+     *
+     * @type {ObservableInput<Bookmark | null | undefined>}
+     */
+    readonly currentBookmark$: Observable<Bookmark | null | undefined>;
+
+    readonly bookmarks$: Observable<BookmarkWithoutData[]>;
+
+    /**
+     * Observable status of the bookmark provider.
+     */
+    readonly status$: Observable<BookmarkState['status']>;
+
+    /**
+     * Indicates whether the user can create bookmarks.
+     * If no payload generator is provided, this will always be false.
+     *
+     * @type {boolean}
+     */
+    readonly canCreateBookmarks: boolean;
+
+    /**
+     * fetch a bookmark by its ID.
+     *
+     * @param {string} bookmarkId - The ID of the bookmark to fetch.
+     * @returns {ObservableInput<Bookmark>} An observable input of the bookmark.
+     */
+    getBookmark(bookmarkId: string): ObservableInput<Bookmark>;
+
+    /**
+     * Fetches all bookmarks.
+     *
+     * @returns {ObservableInput<Bookmark[]>} An observable input of the bookmarks.
+     */
+    getAllBookmarks(): ObservableInput<Bookmark[]>;
+
+    /**
+     * Sets the current bookmark.
+     *
+     * @param {Bookmark | string | null} bookmark_or_id - The bookmark or its ID to set as current.
+     * @returns {ObservableInput<Bookmark | null>} An observable input of the current bookmark.
+     */
+    setCurrentBookmark(bookmark_or_id: Bookmark | string | null): ObservableInput<Bookmark | null>;
+
+    /**
+     * Creates a new bookmark.
+     *
+     * @param {BookmarkCreateArgs} newBookmarkData - The data for the new bookmark.
+     * @returns {ObservableInput<Bookmark>} An observable input of the created bookmark.
+     */
+    createBookmark(newBookmarkData: BookmarkCreateArgs): ObservableInput<Bookmark>;
+
+    /**
+     * Updates an existing bookmark.
+     *
+     * @param {string} bookmarkId - The ID of the bookmark to update.
+     * @param {BookmarkUpdate} [bookmarkUpdates] - The updates to apply to the bookmark.
+     * @param {BookmarkUpdateOptions} [options] - Additional options for the update.
+     * @returns {ObservableInput<Bookmark>} An observable input of the updated bookmark.
+     */
+    updateBookmark(
+        bookmarkId: string,
+        bookmarkUpdates?: BookmarkUpdate,
+        options?: BookmarkUpdateOptions,
+    ): ObservableInput<Bookmark>;
+
+    /**
+     * Deletes a bookmark.
+     *
+     * @param {string} bookmarkId - The ID of the bookmark to delete.
+     * @returns {ObservableInput<void>} An observable input indicating the deletion.
+     */
+    deleteBookmark(bookmarkId: string): ObservableInput<void>;
+
+    /**
+     * Adds a bookmark to the favorites.
+     *
+     * @param {string} bookmarkId - The ID of the bookmark to add to favorites.
+     * @returns {ObservableInput<void>} An observable input indicating the addition.
+     */
+    addBookmarkToFavorites(bookmarkId: string): ObservableInput<BookmarkWithoutData | undefined>;
+
+    /**
+     * Removes a bookmark from the favorites.
+     *
+     * @param {string} bookmarkId - The ID of the bookmark to remove from favorites.
+     * @returns {ObservableInput<void>} An observable input indicating the removal.
+     */
+    removeBookmarkAsFavorite(bookmarkId: string): ObservableInput<void>;
+
+    /**
+     * Checks if a bookmark is in the favorites.
+     *
+     * @param bookmarkId
+     * @returns {ObservableInput<boolean>} An observable input indicating whether the bookmark is in the favorites.
+     */
+    isBookmarkInFavorites(bookmarkId: string): ObservableInput<boolean>;
+
+    addPayloadGenerator<TData extends BookmarkData>(
+        generator: BookmarkPayloadGenerator<TData>,
+    ): VoidFunction;
+
+    /**
+     * Registers an event listener for bookmark provider events.
+     *
+     * @param {TType} eventName - The name of the event to listen for.
+     * @param {(event: BookmarkProviderEventMap[TType]) => void} callback - The callback to invoke when the event is triggered.
+     * @returns {VoidFunction} A function to unregister the event listener.
+     */
+    on<TType extends keyof BookmarkProviderEventMap>(
+        eventName: TType,
+        callback: (event: BookmarkProviderEventMap[TType]) => void,
+    ): VoidFunction;
+}

packages/modules/bookmark/src/BookmarkProvider.selectors.ts

@@ -29,9 +29,8 @@ export const bookmarkSelector = <T extends BookmarkData>(
  */
 export const activeBookmarkSelector = <T extends BookmarkData>(
     state: BookmarkState,
-): Bookmark<T> | null => {
-    const selectedBookmark = state.currentBookmark as Bookmark<T>;
-    return selectedBookmark || null;
+): Bookmark<T> | null | undefined => {
+    return state.currentBookmark as Bookmark<T> | null | undefined;
 };
 
 /**