@equinor/fusion-framework-module-bookmark 4.1.0 → 4.1.2

package/src/BookmarkProviderError.ts

@@ -1,19 +0,0 @@
-/**
- * General-purpose error thrown by {@link BookmarkProvider} methods when a
- * high-level operation (create, update, delete, set current, etc.) fails.
- *
- * Distinct from {@link BookmarkFlowError}, which is scoped to internal
- * store flow pipelines.
- */
-export class BookmarkProviderError extends Error {
-  /**
-   * Constructs a new `BookmarkProviderError`.
-   *
-   * @param message - Human-readable error message.
-   * @param options - Optional `ErrorOptions` (e.g. `cause`).
-   */
-  constructor(message: string, options?: ErrorOptions) {
-    super(message, options);
-    this.name = 'BookmarkProviderError';
-  }
-}

package/src/__tests__/mock/bookmark-mock.test.ts

@@ -1,199 +0,0 @@
-import { firstValueFrom, from, type ObservableInput } from 'rxjs';
-import { describe, expect, it } from 'vitest';
-
-import { ModulesConfigurator } from '@equinor/fusion-framework-module';
-
-import { BookmarkModuleConfigurator } from '../../BookmarkModuleConfigurator';
-import { BookmarkProvider } from '../../BookmarkProvider';
-import type { IBookmarkProvider } from '../../BookmarkProvider.interface';
-import { module as realModule } from '../../bookmark-module';
-import type { Bookmark } from '../../types';
-
-import {
-  BookmarkMockClient,
-  BookmarkMockConfigurator,
-  bookmarkMockModule,
-  enableBookmarkMock,
-} from '../../mock';
-
-/** A fully-formed seeded bookmark, so tests only override what they care about. */
-const createBookmark = (overrides: Partial<Bookmark> = {}): Bookmark => ({
-  id: 'bookmark-1',
-  name: 'My Bookmark',
-  appKey: 'test-app',
-  created: new Date('2024-01-01T00:00:00.000Z'),
-  createdBy: { id: 'seed-user', name: 'Seed User' },
-  ...overrides,
-});
-
-/**
- * Initializes the mock module through the real module system.
- *
- * @remarks
- * Deliberately avoids hand-building initialization arguments — faking the
- * module system is the very cost this mock removes.
- *
- * @param configure - Optional callback to seed bookmarks, current bookmark, or favorites.
- * @returns The `IBookmarkProvider` the module produced.
- */
-const initializeMockWith = async (
-  configure?: (builder: BookmarkMockConfigurator) => void,
-): Promise<IBookmarkProvider> => {
-  const configurator = new ModulesConfigurator([]);
-  enableBookmarkMock(configurator, configure);
-  const instances = await configurator.initialize();
-  return (instances as unknown as { bookmark: IBookmarkProvider }).bookmark;
-};
-
-/**
- * Resolves the first value of an `IBookmarkProvider` call.
- *
- * @remarks
- * `IBookmarkProvider`'s methods are typed as `ObservableInput`, not `Observable`,
- * so this wraps with `from()` before handing off to `firstValueFrom`.
- *
- * @template T - The value the observable input emits.
- * @param input - The observable input to resolve.
- * @returns A promise resolving to the first emitted value.
- */
-const firstValue = <T>(input: ObservableInput<T>): Promise<T> => firstValueFrom(from(input));
-
-describe('bookmarkMockModule', () => {
-  it('changes nothing but the configurator', () => {
-    expect(bookmarkMockModule.name).toBe(realModule.name);
-    expect(bookmarkMockModule.version).toBe(realModule.version);
-    // The production initializer, untouched — the mock has no lifecycle of its own
-    expect(bookmarkMockModule.initialize).toBe(realModule.initialize);
-  });
-
-  it('builds a real BookmarkModuleConfigurator, so the whole builder stays available', () => {
-    const configurator = bookmarkMockModule.configure?.();
-
-    expect(configurator).toBeInstanceOf(BookmarkModuleConfigurator);
-    expect(configurator).toBeInstanceOf(BookmarkMockConfigurator);
-  });
-});
-
-describe('enableBookmarkMock', () => {
-  it('produces the real BookmarkProvider, not a stand-in', async () => {
-    const provider = await initializeMockWith();
-
-    expect(provider).toBeInstanceOf(BookmarkProvider);
-  });
-
-  it('replaces a bookmark module that is already registered', async () => {
-    // A FrameworkConfigurator pre-registers the real bookmark module, so the
-    // mock is only useful if registering it afterwards wins
-    const configurator = new ModulesConfigurator([realModule]);
-    enableBookmarkMock(configurator, (builder) => {
-      builder.setBookmarks([createBookmark()]);
-    });
-
-    const instances = await configurator.initialize();
-    const provider = (instances as unknown as { bookmark: IBookmarkProvider }).bookmark;
-
-    const bookmarks = await firstValue(provider.getAllBookmarks());
-    expect(bookmarks).toHaveLength(1);
-  });
-
-  it('reflects seeded bookmarks with no real HTTP', async () => {
-    const seeded = createBookmark();
-    const provider = await initializeMockWith((builder) => {
-      builder.setBookmarks([seeded]);
-    });
-
-    const bookmarks = await firstValue(provider.getAllBookmarks());
-    expect(bookmarks.map((b) => b.id)).toEqual([seeded.id]);
-  });
-
-  it('reflects the seeded current bookmark', async () => {
-    const seeded = createBookmark();
-    const provider = await initializeMockWith((builder) => {
-      builder.setBookmarks([seeded]);
-      builder.setCurrentBookmark(seeded.id);
-    });
-
-    expect(provider.currentBookmark?.id).toBe(seeded.id);
-  });
-
-  it('leaves the current bookmark unset when none is seeded', async () => {
-    const provider = await initializeMockWith((builder) => {
-      builder.setBookmarks([createBookmark()]);
-    });
-
-    expect(provider.currentBookmark).toBeNull();
-  });
-
-  it('reflects a seeded favorite', async () => {
-    const seeded = createBookmark();
-    const provider = await initializeMockWith((builder) => {
-      builder.setBookmarks([seeded]);
-      builder.setFavorite(seeded.id, true);
-    });
-
-    await expect(firstValue(provider.isBookmarkInFavorites(seeded.id))).resolves.toBe(true);
-  });
-
-  it('creates a bookmark through the real create flow', async () => {
-    const provider = await initializeMockWith();
-    // without a payload generator, generatePayload() never emits and the create
-    // flow would hang forever waiting on it
-    provider.addPayloadGenerator(() => {});
-
-    const created = await firstValue(
-      provider.createBookmark({ name: 'New Bookmark', appKey: 'test-app' }),
-    );
-
-    expect(created.name).toBe('New Bookmark');
-    const bookmarks = await firstValue(provider.getAllBookmarks());
-    expect(bookmarks.map((b) => b.id)).toContain(created.id);
-  });
-
-  it('updates a bookmark through the real update flow', async () => {
-    const seeded = createBookmark();
-    const provider = await initializeMockWith((builder) => {
-      builder.setBookmarks([seeded]);
-    });
-    // the update reducer only applies to bookmarks already tracked in the store,
-    // so fetch once first to seed it
-    await firstValue(provider.getAllBookmarks());
-
-    const updated = await firstValue(
-      provider.updateBookmark(seeded.id, { name: 'Renamed' }, { excludePayloadGeneration: true }),
-    );
-
-    expect(updated.name).toBe('Renamed');
-  });
-
-  it('surfaces a missing bookmark as an observable error through the real fetch flow', async () => {
-    const provider = await initializeMockWith();
-
-    await expect(firstValue(provider.getBookmark('missing-bookmark'))).rejects.toThrow();
-  });
-
-  it('deletes a bookmark through the real delete flow', async () => {
-    const seeded = createBookmark();
-    const provider = await initializeMockWith((builder) => {
-      builder.setBookmarks([seeded]);
-    });
-
-    await firstValue(provider.deleteBookmark(seeded.id));
-
-    const bookmarks = await firstValue(provider.getAllBookmarks());
-    expect(bookmarks.map((b) => b.id)).not.toContain(seeded.id);
-  });
-
-  it('lets setClient() replace the mock client outright', async () => {
-    const ownClient = new BookmarkMockClient();
-    ownClient.setBookmarks([createBookmark({ id: 'own-bookmark' })]);
-
-    const provider = await initializeMockWith((builder) => {
-      // the escape hatch is inherited unchanged from BookmarkModuleConfigurator
-      builder.setBookmarks([createBookmark({ id: 'ignored-bookmark' })]);
-      builder.setClient(ownClient);
-    });
-
-    const bookmarks = await firstValue(provider.getAllBookmarks());
-    expect(bookmarks.map((b) => b.id)).toEqual(['own-bookmark']);
-  });
-});

package/src/bookmark-actions.ts

@@ -1,132 +0,0 @@
-import {
-  type Action,
-  createAction,
-  createAsyncAction,
-  type ActionTypes,
-} from '@equinor/fusion-observable';
-
-import type { Bookmark, BookmarkData, BookmarkWithoutData, Bookmarks } from './types';
-
-import type { BookmarkNew, BookmarkUpdate, BookmarksFilter } from './BookmarkClient.interface';
-import type { BookmarkFlowError } from './BookmarkFlowError';
-
-/**
- * Represents the metadata associated with a bookmark action.
- */
-type BookmarkActionMeta = {
-  // A reference identifier for the request.
-  ref: string;
-};
-
-/**
- * Actions related to the BookmarkProvider provider state.
- *
- * Exports a set of actions that can be used to manage bookmarks.
- */
-export const bookmarkActions = {
-  aborted: createAction('action_aborted', (action: Action) => ({
-    payload: action,
-  })),
-  setBookmark: createAction('set_bookmark', (bookmark: BookmarkWithoutData) => {
-    return { payload: bookmark };
-  }),
-  setCurrentBookmark: createAction('set_current_bookmark', (bookmark: Bookmark | null) => {
-    return { payload: bookmark };
-  }),
-  fetchBookmark: createAsyncAction(
-    'fetch_bookmark',
-    (bookmarkId: string, meta?: BookmarkActionMeta) => ({
-      payload: bookmarkId,
-      meta,
-    }),
-    (bookmark: BookmarkWithoutData, meta?: BookmarkActionMeta) => ({ payload: bookmark, meta }),
-    (error: BookmarkFlowError, meta?: BookmarkActionMeta) => ({ payload: error, meta }),
-  ),
-  fetchBookmarkData: createAsyncAction(
-    'fetch_bookmark_payload',
-    (bookmarkId: string, meta?: BookmarkActionMeta) => ({ payload: bookmarkId, meta }),
-    (bookmarkId: string, data: BookmarkData, meta?: BookmarkActionMeta) => ({
-      payload: { bookmarkId, data },
-      meta,
-    }),
-    (error: BookmarkFlowError, meta?: BookmarkActionMeta) => ({ payload: error, meta }),
-  ),
-  fetchBookmarks: createAsyncAction(
-    'fetch_bookmarks',
-    (filter?: BookmarksFilter, meta?: BookmarkActionMeta) => ({ payload: filter, meta }),
-    (bookmarks: Bookmarks, meta?: BookmarkActionMeta) => ({ payload: bookmarks, meta }),
-    (error: BookmarkFlowError, meta?: BookmarkActionMeta) => ({ payload: error, meta }),
-  ),
-  updateBookmark: createAsyncAction(
-    'set_bookmark',
-    (payload: { bookmarkId: string; updates: BookmarkUpdate }, meta: BookmarkActionMeta) => ({
-      payload,
-      meta,
-    }),
-    (payload: Bookmark, meta: BookmarkActionMeta) => ({ payload, meta }),
-    (payload: BookmarkFlowError, meta: BookmarkActionMeta) => ({ payload, meta }),
-  ),
-  createBookmark: createAsyncAction(
-    'create_bookmark',
-    (payload: BookmarkNew, meta: BookmarkActionMeta) => ({ payload, meta }),
-    (payload: Bookmark, meta: BookmarkActionMeta) => ({ payload, meta }),
-    (payload: BookmarkFlowError, meta: BookmarkActionMeta) => ({ payload, meta }),
-  ),
-  deleteBookmark: createAsyncAction(
-    'delete_bookmark',
-    (bookmarkId: string, meta?: BookmarkActionMeta) => ({
-      payload: bookmarkId,
-      meta: { ref: bookmarkId, ...meta },
-    }),
-    (bookmarkId: string, meta?: BookmarkActionMeta) => ({
-      payload: bookmarkId,
-      meta: { ref: bookmarkId, ...meta },
-    }),
-    (payload: BookmarkFlowError, meta: BookmarkActionMeta) => ({ payload, meta }),
-  ),
-  removeBookmark: createAsyncAction(
-    'remove_bookmark',
-    (bookmarkId: string, meta?: BookmarkActionMeta) => ({
-      payload: bookmarkId,
-      meta: { ref: bookmarkId, ...meta },
-    }),
-    (
-      payload: {
-        type: 'delete_bookmark' | 'remove_favourite_bookmark';
-        bookmarkId: string;
-      },
-      meta: BookmarkActionMeta,
-    ) => ({ payload, meta }),
-    (payload: BookmarkFlowError, meta: BookmarkActionMeta) => ({
-      payload,
-      meta,
-    }),
-  ),
-  addBookmarkAsFavourite: createAsyncAction(
-    'add_favourite_bookmark',
-    (bookmarkId: string, meta?: BookmarkActionMeta) => ({
-      payload: bookmarkId,
-      meta: { ref: bookmarkId, ...meta },
-    }),
-    (bookmarkId: string, meta?: BookmarkActionMeta) => ({
-      payload: bookmarkId,
-      meta: { ref: bookmarkId, ...meta },
-    }),
-    (error: BookmarkFlowError, meta: BookmarkActionMeta) => ({ payload: error, meta }),
-  ),
-  removeBookmarkAsFavourite: createAsyncAction(
-    'remove_favourite_bookmark',
-    (bookmarkId: string, meta?: BookmarkActionMeta) => ({
-      payload: bookmarkId,
-      meta: { ref: bookmarkId, ...meta },
-    }),
-    (bookmarkId: string, meta?: BookmarkActionMeta) => ({
-      payload: bookmarkId,
-      meta: { ref: bookmarkId, ...meta },
-    }),
-    (error: BookmarkFlowError, meta: BookmarkActionMeta) => ({ payload: error, meta }),
-  ),
-};
-
-/** Union type of all action objects produced by {@link bookmarkActions}. */
-export type BookmarkActions = ActionTypes<typeof bookmarkActions>;

package/src/bookmark-config.schema.ts

@@ -1,55 +0,0 @@
-import { z } from 'zod';
-
-import { LogLevel, type ILogger } from '@equinor/fusion-log';
-
-import type { IEventModuleProvider } from '@equinor/fusion-framework-module-event';
-
-import type { IBookmarkProvider } from './BookmarkProvider.interface';
-import type { IBookmarkClient } from './BookmarkClient.interface';
-
-import { bookmarkSourceSystemSchema } from './bookmark.schemas';
-import type { BookmarkModuleConfig } from './types';
-
-/**
- * Zod schema that validates the full {@link BookmarkModuleConfig} object.
- *
- * Used internally by {@link BookmarkModuleConfigurator} to verify the resolved
- * configuration before the bookmark module is initialised.
- */
-export const bookmarkConfigSchema = z.object({
-  log: z.custom<ILogger>().optional(),
-  logLevel: z.nativeEnum(LogLevel).optional(),
-  eventProvider: z.custom<IEventModuleProvider>().optional(),
-  sourceSystem: bookmarkSourceSystemSchema
-    .optional()
-    .describe('The source system for the bookmarks'),
-  parent: z.custom<IBookmarkProvider>().describe('Parent Bookmark provider').optional().nullable(),
-  client: z.custom<IBookmarkClient>().describe('API client for interacting with bookmarks'),
-  resolve: z
-    .object({
-      context: z.function(),
-      application: z.function(),
-    })
-    .describe('Functions for resolving context and application'),
-  filters: z
-    .object({
-      context: z.boolean().optional().default(false),
-      application: z.boolean().optional().default(false),
-    })
-    .describe('Flags for enabling resolving when fetching bookmarks')
-    .optional()
-    .default({ context: false, application: false }),
-});
-
-/**
- * Parses an unknown configuration object against {@link bookmarkConfigSchema}.
- *
- * @param config - The raw config value to validate.
- * @returns A validated {@link BookmarkModuleConfig}.
- * @throws {ZodError} When validation fails.
- */
-// tightly coupled parse helper for the schema above
-// fusion-lint-disable-next-line single-export-per-file
-export const parseBookmarkConfig = (config: unknown): BookmarkModuleConfig => {
-  return bookmarkConfigSchema.parse(config) as BookmarkModuleConfig;
-};

package/src/bookmark-flows/bookmark-api-flows.ts

@@ -1,45 +0,0 @@
-import { of, type Observable } from 'rxjs';
-import { mergeMap } from 'rxjs/operators';
-
-import type { Flow } from '@equinor/fusion-observable';
-
-import type { BookmarkActions } from '../bookmark-actions';
-import type { BookmarkState } from '../create-bookmark-store';
-import type { IBookmarkClient } from '../BookmarkClient.interface';
-
-import { handleFetchBookmark } from './handle-fetch-bookmark';
-import { handleFetchBookmarkData } from './handle-fetch-bookmark-data';
-import { handleFetchAllBookmark } from './handle-fetch-all-bookmark';
-import { handleCreateBookmark } from './handle-create-bookmark';
-import { handleUpdateBookmark } from './handle-update-bookmark';
-import { handleDeleteBookmark } from './handle-delete-bookmark';
-import { handleRemoveBookmark } from './handle-remove-bookmark';
-import { handleRemoveBookmarkFromFavorites } from './handle-remove-bookmark-from-favorites';
-import { handleAddBookmarkAsFavorite } from './handle-add-bookmark-as-favorite';
-
-/**
- * Defines a set of flows that handle various bookmark-related actions, such as fetching, creating, updating, and deleting bookmarks.
- *
- * @param api - An instance of `IBookmarkClient` that provides the necessary API methods for interacting with the bookmark service.
- * @returns A combined flow that handles all the bookmark-related actions.
- */
-export const bookmarkApiFlows = (api: IBookmarkClient): Flow<BookmarkActions, BookmarkState> => {
-  /**
-   * Combines multiple Bookmark-related observable flows into a single observable stream.
-   * The resulting observable stream emits the combined effects of these flows,
-   * which can be used to update the application state.
-   */
-  return (actions$: Observable<BookmarkActions>, state$: Observable<BookmarkState>) =>
-    // Invoke every bookmark flow with the shared api client and merge their emissions.
-    of(
-      handleFetchBookmark,
-      handleFetchBookmarkData,
-      handleFetchAllBookmark,
-      handleCreateBookmark,
-      handleUpdateBookmark,
-      handleDeleteBookmark,
-      handleRemoveBookmark,
-      handleRemoveBookmarkFromFavorites,
-      handleAddBookmarkAsFavorite,
-    ).pipe(mergeMap((flow) => flow(api)(actions$, state$)));
-};

package/src/bookmark-flows/handle-add-bookmark-as-favorite.ts

@@ -1,49 +0,0 @@
-import { of, from } from 'rxjs';
-import { concatMap, map, catchError, filter, last } from 'rxjs/operators';
-
-import type { Flow, Observable } from '@equinor/fusion-observable';
-
-import { bookmarkActions as actions, type BookmarkActions } from '../bookmark-actions';
-import type { IBookmarkClient } from '../BookmarkClient.interface';
-import { BookmarkFlowError } from '../BookmarkFlowError';
-
-/**
- * Handles the flow of adding a bookmark as a favorite.
- *
- * @param api - The `IBookmarkClient` API instance to use for interacting with bookmarks.
- * @returns An RxJS `Flow` that handles the `addBookmarkAsFavourite` action.
- */
-export const handleAddBookmarkAsFavorite =
-  (api: IBookmarkClient): Flow<BookmarkActions> =>
-  (action$: Observable<BookmarkActions>) => {
-    /**
-     * Handles the flow for adding a bookmark as a favorite.
-     *
-     * This flow listens for the `addBookmarkAsFavourite` action, and then:
-     * 1. Calls the `addBookmarkToFavorites` API to add the bookmark to the user's favorites.
-     * 2. If the API call is successful, dispatches the `addBookmarkAsFavourite.success` action.
-     * 3. If the API call fails, dispatches the `addBookmarkAsFavourite.failure` action with an error.
-     */
-    const flow$ = action$.pipe(
-      filter(actions.addBookmarkAsFavourite.match),
-      concatMap((action) =>
-        // Map the API call outcome to a success or failure action for this bookmark.
-        from(api.addBookmarkToFavorites(action.payload)).pipe(
-          last(),
-          map(() => actions.addBookmarkAsFavourite.success(action.payload, action.meta)),
-          catchError((error) =>
-            of(
-              actions.addBookmarkAsFavourite.failure(
-                new BookmarkFlowError('Failed to add bookmark as favorite', action, {
-                  cause: error,
-                }),
-                action.meta,
-              ),
-            ),
-          ),
-        ),
-      ),
-    );
-
-    return flow$;
-  };

package/src/bookmark-flows/handle-create-bookmark.ts

@@ -1,47 +0,0 @@
-import { of, from } from 'rxjs';
-import { concatMap, map, catchError, filter, last } from 'rxjs/operators';
-
-import type { Flow, Observable } from '@equinor/fusion-observable';
-
-import { bookmarkActions as actions, type BookmarkActions } from '../bookmark-actions';
-import type { IBookmarkClient } from '../BookmarkClient.interface';
-import { BookmarkFlowError } from '../BookmarkFlowError';
-
-/**
- * Creates a Flow for handling creating bookmarks.
- *
- * @param api - An instance of the `IBookmarkClient` interface, which provides the necessary API methods for creating bookmarks.
- * @returns A flow that listens for `createBookmark` actions, creates a new bookmark using the provided API.
- */
-export const handleCreateBookmark =
-  (api: IBookmarkClient): Flow<BookmarkActions> =>
-  (action$: Observable<BookmarkActions>) => {
-    /**
-     * This flow listens for the `createBookmark` action, and then uses the `api.createBookmark` function to create a new bookmark.
-     * If the bookmark is created successfully, it dispatches the `createBookmark.success` action with the new bookmark.
-     * If there is an error creating the bookmark, it dispatches the `fetchBookmark.failure` action with an error.
-     *
-     * The `concatMap` operator is used to prevent aborting the request if a new `createBookmark` action is dispatched while the previous request is in flight.
-     */
-    const flow$ = action$.pipe(
-      filter(actions.createBookmark.match),
-      concatMap((action) => {
-        // wait for the final emission before mapping to a success/failure action
-        return from(api.createBookmark(action.payload)).pipe(
-          last(),
-          map((bookmark) => actions.createBookmark.success(bookmark, action.meta)),
-          catchError((error) =>
-            of(
-              actions.createBookmark.failure(
-                new BookmarkFlowError('Failed to create new bookmark', action, {
-                  cause: error,
-                }),
-                action.meta,
-              ),
-            ),
-          ),
-        );
-      }),
-    );
-    return flow$;
-  };

package/src/bookmark-flows/handle-delete-bookmark.ts

@@ -1,47 +0,0 @@
-import { of, from } from 'rxjs';
-import { concatMap, map, catchError, filter, last } from 'rxjs/operators';
-
-import type { Flow, Observable } from '@equinor/fusion-observable';
-
-import { bookmarkActions as actions, type BookmarkActions } from '../bookmark-actions';
-import type { IBookmarkClient } from '../BookmarkClient.interface';
-import { BookmarkFlowError } from '../BookmarkFlowError';
-
-/**
- * Creates a flow for handling deleting bookmarks.
- *
- * @param api - An instance of the `IBookmarkClient` interface, which provides the necessary API methods for deleting bookmarks.
- * @returns A flow that listens for `deleteBookmark` actions, deletes the bookmark using the provided API.
- */
-export const handleDeleteBookmark =
-  (api: IBookmarkClient): Flow<BookmarkActions> =>
-  (action$: Observable<BookmarkActions>) => {
-    /**
-     * - Listens for the `deleteBookmark` action.
-     * - Calls the `api.deleteBookmark` function to delete the bookmark.
-     * - Maps the successful response to the `deleteBookmark.success` action.
-     * - Handles errors by dispatching the `fetchBookmark.failure` action with a `BookmarkFlowError`.
-     * - Uses `concatMap` to prevent aborting the request if a new action is dispatched while the previous request is in flight.
-     */
-    const flow$ = action$.pipe(
-      filter(actions.deleteBookmark.match),
-      concatMap((action) =>
-        // Map the API call outcome to a success or failure action for this bookmark.
-        from(api.deleteBookmark(action.payload)).pipe(
-          last(),
-          map(() => actions.deleteBookmark.success(action.payload, action.meta)),
-          catchError((error) =>
-            of(
-              actions.deleteBookmark.failure(
-                new BookmarkFlowError('Failed to delete bookmark', action, {
-                  cause: error,
-                }),
-                action.meta,
-              ),
-            ),
-          ),
-        ),
-      ),
-    );
-    return flow$;
-  };

package/src/bookmark-flows/handle-fetch-all-bookmark.ts

@@ -1,53 +0,0 @@
-import { of, from } from 'rxjs';
-import { throttleTime, groupBy, switchMap, map, catchError, filter, last } from 'rxjs/operators';
-
-import type { Flow, Observable } from '@equinor/fusion-observable';
-
-import { bookmarkActions as actions, type BookmarkActions } from '../bookmark-actions';
-import type { IBookmarkClient } from '../BookmarkClient.interface';
-import { BookmarkFlowError } from '../BookmarkFlowError';
-
-const defaultThrottleTime = 200;
-
-/**
- * Creates a Flow for handling fetching users bookmarks.
- *
- * @param api - The bookmark API client to use for fetching bookmarks.
- * @returns An observable that emits the result of the bookmark fetch operation.
- */
-export const handleFetchAllBookmark =
-  (api: IBookmarkClient): Flow<BookmarkActions> =>
-  (action$: Observable<BookmarkActions>) => {
-    /**
-     * This flow is triggered by the `fetchBookmarks` action and uses the `throttleTime` operator
-     * to limit the number of requests made to the API. The `switchMap` operator is used to make
-     * the API call and map the response to the appropriate action (success or failure).
-     */
-    const flow$ = action$.pipe(
-      filter(actions.fetchBookmarks.match),
-      // group requests by filter so throttling only applies per-filter
-      groupBy((action) => JSON.stringify(action.payload)),
-      switchMap((group) =>
-        // avoid flooding the API with repeated requests for the same filter
-        group.pipe(throttleTime(defaultThrottleTime)),
-      ),
-      switchMap((action) =>
-        // Map the API call outcome to a success or failure action for this filter.
-        from(api.getAllBookmarks(action.payload)).pipe(
-          last(),
-          map((value) => actions.fetchBookmarks.success(value, action.meta)),
-          catchError((error) =>
-            of(
-              actions.fetchBookmarks.failure(
-                new BookmarkFlowError('Failed to fetch all bookmarks', action, {
-                  cause: error,
-                }),
-                action.meta,
-              ),
-            ),
-          ),
-        ),
-      ),
-    );
-    return flow$;
-  };