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

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

@@ -1,58 +0,0 @@
-import { of, from } from 'rxjs';
-import {
-  throttleTime,
-  groupBy,
-  mergeMap,
-  switchMap,
-  map,
-  catchError,
-  filter,
-  last,
-} from 'rxjs/operators';
-
-import type { Flow } 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 bookmark data.
- *
- * @param api - The bookmark client API.
- * @returns A flow of bookmark actions.
- */
-export const handleFetchBookmarkData =
-  (api: IBookmarkClient): Flow<BookmarkActions> =>
-  (action$) => {
-    // throttle requests per bookmark id, then fetch the data and dispatch success/failure
-    const flow$ = action$.pipe(
-      filter(actions.fetchBookmarkData.match),
-      // group requests by bookmark id so throttling only applies per-id
-      groupBy((action) => JSON.stringify(action.payload)),
-      mergeMap((group) =>
-        // avoid flooding the API with repeated requests for the same bookmark
-        group.pipe(throttleTime(defaultThrottleTime)),
-      ),
-      switchMap((action) => {
-        // wait for the final emission before mapping to a success/failure action
-        return from(api.getBookmarkData(action.payload)).pipe(
-          last(),
-          map((data) => actions.fetchBookmarkData.success(action.payload, data, action.meta)),
-          catchError((error) =>
-            of(
-              actions.fetchBookmarkData.failure(
-                new BookmarkFlowError('Failed to fetch bookmark payload', action, {
-                  cause: error,
-                }),
-                action.meta,
-              ),
-            ),
-          ),
-        );
-      }),
-    );
-    return flow$;
-  };

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

@@ -1,64 +0,0 @@
-import { of } from 'rxjs';
-import {
-  throttleTime,
-  groupBy,
-  mergeMap,
-  switchMap,
-  map,
-  catchError,
-  filter,
-  last,
-} from 'rxjs/operators';
-
-import { from } from 'rxjs';
-
-import type { Flow } 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;
-
-/**
- * Handles the fetch bookmark action by making an API request to get the bookmark by its ID.
- *
- * @param api - The bookmark client API.
- * @returns A flow that handles the fetch bookmark action.
- */
-export const handleFetchBookmark =
-  (api: IBookmarkClient): Flow<BookmarkActions> =>
-  (action$) => {
-    /**
-     * Observable that represents the flow of fetching bookmarks.
-     * It listens for `fetchBookmark` actions, makes an API request to get the bookmark by ID,
-     * and emits corresponding success or failure actions based on the API response.
-     */
-    const flow$ = action$.pipe(
-      filter(actions.fetchBookmark.match),
-      // group requests by bookmark id so throttling only applies per-id
-      groupBy((action) => action.payload),
-      mergeMap((group) =>
-        // avoid flooding the API with repeated requests for the same bookmark
-        group.pipe(throttleTime(defaultThrottleTime)),
-      ),
-      switchMap((action) =>
-        // Map the API call outcome to a success or failure action for this bookmark.
-        from(api.getBookmarkById(action.payload)).pipe(
-          last(),
-          map((bookmark) => actions.fetchBookmark.success(bookmark, action.meta)),
-          catchError((error) =>
-            of(
-              actions.fetchBookmark.failure(
-                new BookmarkFlowError('Failed to fetch bookmark', action, {
-                  cause: error,
-                }),
-                action.meta,
-              ),
-            ),
-          ),
-        ),
-      ),
-    );
-    return flow$;
-  };

package/src/bookmark-flows/handle-remove-bookmark-from-favorites.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';
-
-/**
- * Creates a Flow for handling removing a bookmark from favorites.
- *
- * @param api - An instance of the `IBookmarkClient` interface, which provides the necessary API methods for managing favorite bookmarks.
- * @returns A flow that listens for `removeBookmarkAsFavorite` actions, removes the bookmark from the user's favorites using the provided API.
- */
-export const handleRemoveBookmarkFromFavorites =
-  (api: IBookmarkClient): Flow<BookmarkActions> =>
-  (action$: Observable<BookmarkActions>) => {
-    /**
-     * - Listens for the `removeBookmarkAsFavourite` action.
-     * - Calls the `api.removeBookmarkFromFavorites` function to remove the bookmark from favorites.
-     * - On success, dispatches the `removeBookmarkAsFavourite.success` action.
-     * - On error, dispatches 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.removeBookmarkAsFavourite.match),
-      // use concatMap to prevent aborting the request if a new action is dispatched while the previous request is in flight
-      concatMap((action) =>
-        // Map the API call outcome to a success or failure action for this bookmark.
-        from(api.removeBookmarkFromFavorites(action.payload)).pipe(
-          last(),
-          map(() => actions.removeBookmarkAsFavourite.success(action.payload, action.meta)),
-          catchError((error) =>
-            of(
-              actions.removeBookmarkAsFavourite.failure(
-                new BookmarkFlowError('Failed to remove bookmark as favorite', action, {
-                  cause: error,
-                }),
-                action.meta,
-              ),
-            ),
-          ),
-        ),
-      ),
-    );
-
-    return flow$;
-  };

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

@@ -1,76 +0,0 @@
-import { concat, merge, from } from 'rxjs';
-import { map, concatMap, filter } from 'rxjs/operators';
-
-import { type Flow, getBaseType } from '@equinor/fusion-observable';
-
-import { bookmarkActions as actions, type BookmarkActions } from '../bookmark-actions';
-import type { IBookmarkClient } from '../BookmarkClient.interface';
-
-/**
- * Creates a flow for handling bookmark removal.
- *
- * This function observes actions related to deleting a bookmark or removing a bookmark as a favorite, and dispatches the appropriate actions for each case.
- * If the bookmark is currently a favorite, it will dispatch an action to remove it as a favorite.
- * If the bookmark is not a favorite, it will dispatch an action to delete it.
- *
- * @param api - An instance of the `IBookmarkClient` interface, which provides the necessary API methods checking if bookmarks are favorites.
- * @returns A flow that handles the removal of a bookmark.
- */
-export const handleRemoveBookmark =
-  (api: IBookmarkClient): Flow<BookmarkActions> =>
-  (action$) => {
-    /**
-     * Handles the removal of a bookmark from the application.
-     *
-     * This function is responsible for determining whether the bookmark being removed is a favorite or not,
-     * and then dispatching the appropriate action to either remove the bookmark as a favorite or delete the bookmark entirely.
-     *
-     * Uses `concatMap` to prevent aborting the request if a new action is dispatched while the previous request is in flight.
-     */
-    const dispatch$ = action$.pipe(
-      filter(actions.removeBookmark.match),
-      concatMap(({ payload: bookmarkId }) => {
-        // pick which action to dispatch based on the bookmark's favorite status
-        return from(api.isBookmarkFavorite(bookmarkId)).pipe(
-          map((isFavorite) => {
-            const action = isFavorite ? actions.removeBookmarkAsFavourite : actions.deleteBookmark;
-            return action(bookmarkId);
-          }),
-        );
-      }),
-    );
-
-    /**
-     * Handles failures for deleting a bookmark or removing a bookmark as a favorite.
-     */
-    const failure$ = merge(
-      action$.pipe(filter(actions.deleteBookmark.failure.match)),
-      action$.pipe(filter(actions.removeBookmarkAsFavourite.failure.match)),
-    ).pipe(map((action) => actions.removeBookmark.failure(action.payload, action.meta)));
-
-    /**
-     * Handles the success of deleting a bookmark or removing a bookmark as a favorite.
-     */
-    const success$ = merge(
-      action$.pipe(filter(actions.deleteBookmark.success.match)),
-      action$.pipe(filter(actions.removeBookmarkAsFavourite.success.match)),
-    ).pipe(
-      map((action) =>
-        actions.removeBookmark.success(
-          {
-            type: getBaseType(action.type),
-            bookmarkId: action.payload,
-          },
-          action.meta,
-        ),
-      ),
-    );
-
-    /**
-     * First dispatch either deletions of bookmark or removals of bookmarks as favorites.
-     * Then observer the results of those actions and dispatch the appropriate actions.
-     */
-    const flow$ = concat(dispatch$, merge(failure$, success$));
-
-    return flow$;
-  };

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

@@ -1,48 +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 updating bookmarks.
- *
- * @param api - An instance of the `IBookmarkClient` interface, which provides the necessary API methods for updating bookmarks.
- * @returns A flow that listens for `updateBookmark` actions, updates the bookmark using the provided API.
- */
-export const handleUpdateBookmark =
-  (api: IBookmarkClient): Flow<BookmarkActions> =>
-  (action$: Observable<BookmarkActions>) => {
-    /**
-     * This flow listens for `updateBookmark` actions, then calls the `api.updateBookmark` function with the action payload.
-     * If the update is successful, it dispatches a `updateBookmark.success` action with the updated bookmark.
-     * If there is an error, it dispatches a `fetchBookmark.failure` action with the error.
-     *
-     * The `concatMap` operator is used to prevent aborting the request if a new `updateBookmark` action is dispatched while the previous request is in flight.
-     */
-    const flow$ = action$.pipe(
-      filter(actions.updateBookmark.match),
-      concatMap((action) => {
-        const { bookmarkId, updates } = action.payload;
-        // wait for the final emission before mapping to a success/failure action
-        return from(api.updateBookmark(bookmarkId, updates)).pipe(
-          last(),
-          map((bookmark) => actions.updateBookmark.success(bookmark, action.meta)),
-          catchError((error) =>
-            of(
-              actions.updateBookmark.failure(
-                new BookmarkFlowError('Failed to update bookmark', action, {
-                  cause: error,
-                }),
-                action.meta,
-              ),
-            ),
-          ),
-        );
-      }),
-    );
-    return flow$;
-  };

package/src/bookmark-flows/index.ts

@@ -1,10 +0,0 @@
-export { handleFetchBookmark } from './handle-fetch-bookmark';
-export { handleFetchBookmarkData } from './handle-fetch-bookmark-data';
-export { handleFetchAllBookmark } from './handle-fetch-all-bookmark';
-export { handleCreateBookmark } from './handle-create-bookmark';
-export { handleUpdateBookmark } from './handle-update-bookmark';
-export { handleDeleteBookmark } from './handle-delete-bookmark';
-export { handleRemoveBookmark } from './handle-remove-bookmark';
-export { handleRemoveBookmarkFromFavorites } from './handle-remove-bookmark-from-favorites';
-export { handleAddBookmarkAsFavorite } from './handle-add-bookmark-as-favorite';
-export { bookmarkApiFlows } from './bookmark-api-flows';

package/src/bookmark-module.ts

@@ -1,98 +0,0 @@
-import {
-  type Module,
-  type ModulesInstance,
-  SemanticVersion,
-} from '@equinor/fusion-framework-module';
-import type { EventModule } from '@equinor/fusion-framework-module-event';
-import type { ServicesModule } from '@equinor/fusion-framework-module-services';
-import type { AppModule } from '@equinor/fusion-framework-module-app';
-import type { ContextModule } from '@equinor/fusion-framework-module-context';
-import { BookmarkProvider } from './BookmarkProvider';
-import { BookmarkModuleConfigurator } from './BookmarkModuleConfigurator';
-import { ConsoleLogger, type ILogger } from '@equinor/fusion-log';
-import { lastValueFrom } from 'rxjs';
-import { version } from './version';
-import type { IBookmarkProvider } from './BookmarkProvider.interface';
-
-/** String literal key used to register the bookmark module in the framework. */
-export type BookmarkModuleKey = 'bookmark';
-
-/** The module key constant used to identify the bookmark module at runtime. */
-export const moduleKey: BookmarkModuleKey = 'bookmark';
-
-/**
- * Type definition for the bookmark framework module.
- *
- * Declares the module key, provider interface, configurator class,
- * and optional peer dependencies (event, services, app, context modules).
- */
-export type BookmarkModule = Module<
-  BookmarkModuleKey,
-  IBookmarkProvider,
-  BookmarkModuleConfigurator,
-  [EventModule, ServicesModule, AppModule, ContextModule]
->;
-
-// TODO(#5134) - remove when all framework uses log
-const fallbackLogger: ILogger = new ConsoleLogger('BookmarkModule');
-
-/**
- * Bookmark module definition for the Fusion Framework.
- *
- * Handles configuration, initialization (creating a {@link BookmarkProvider}),
- * and disposal of the bookmark module lifecycle.
- *
- * @example
- * ```ts
- * import { enableBookmark } from '@equinor/fusion-framework-module-bookmark';
- *
- * const configure = (configurator) => {
- *   enableBookmark(configurator);
- * };
- * ```
- */
-export const module: BookmarkModule = {
-  name: moduleKey,
-  version: new SemanticVersion(version),
-  configure: (args) => {
-    // use parent logger if available, else fallback to console logger
-    const log: ILogger =
-      (args?.log as ILogger)?.createSubLogger('BookmarkModule') || fallbackLogger;
-
-    // Set client from parent module if available
-    const ref = args?.ref as ModulesInstance<[BookmarkModule]>;
-
-    // create a configurator instance
-    const configurator = new BookmarkModuleConfigurator({ log, ref });
-
-    return configurator;
-  },
-  initialize: async (args) => {
-    const parent = args.ref?.bookmark as BookmarkProvider;
-    const config = await lastValueFrom(
-      args.config.createConfig(args, {
-        filters: parent?.filters,
-        sourceSystem: parent?.sourceSystem,
-        resolve: parent
-          ? {
-              application: parent.resolvedApplication.bind(parent),
-              context: parent.resolvedContext.bind(parent),
-            }
-          : undefined,
-      }),
-    );
-    const provider = new BookmarkProvider(config);
-    return provider;
-  },
-  dispose: (args) => {
-    (args.instance as BookmarkProvider).dispose();
-  },
-};
-
-declare module '@equinor/fusion-framework-module' {
-  interface Modules {
-    bookmark: BookmarkModule;
-  }
-}
-
-export default module;

package/src/bookmark.schemas.ts

@@ -1,81 +0,0 @@
-import * as z from 'zod';
-import type { Bookmark, BookmarkData } from './types';
-
-/** Zod schema for validating {@link BookmarkUser} objects. */
-export const bookmarkUserSchema = z.object({
-  id: z.string(),
-  name: z.string(),
-  mail: z.string().optional(),
-});
-
-/** Zod schema for validating {@link SourceSystem} objects on a bookmark. */
-export const bookmarkSourceSystemSchema = z.object(
-  {
-    identifier: z.string(),
-    name: z.string().nullish(),
-    subSystem: z.string().nullish(),
-  },
-  { message: 'invalid source system' },
-);
-
-/** Zod schema for validating {@link BookmarkContext} objects. */
-export const bookmarkContextSchema = z.object({
-  id: z.string(),
-  name: z.string().optional(),
-  type: z.string().optional(),
-});
-
-/** Zod schema for validating a {@link BookmarkWithoutData} (no payload). */
-export const bookmarkSchema = z.object({
-  id: z.string(),
-  name: z.string(),
-  appKey: z.string(),
-  description: z.string().optional(),
-  isShared: z.boolean().optional(),
-  created: z.date(),
-  createdBy: bookmarkUserSchema,
-  updated: z.date().optional(),
-  updatedBy: bookmarkUserSchema.optional(),
-  context: bookmarkContextSchema.optional(),
-  sourceSystem: bookmarkSourceSystemSchema.nullish(),
-});
-
-/** Zod schema for validating an array of bookmarks. */
-export const bookmarksSchema = z.array(bookmarkSchema);
-
-/**
- * Creates a Zod schema for a {@link Bookmark} that includes a typed payload field.
- *
- * @template T - The bookmark payload data shape.
- * @template S - Zod schema type for the payload.
- * @param schema - Optional Zod schema to validate the payload. Defaults to
- *   `z.record(z.string(), z.unknown()).or(z.string()).optional()`.
- * @returns A Zod object schema extending {@link bookmarkSchema} with a `payload` property.
- */
-export const bookmarkWithDataSchema = <
-  T extends BookmarkData = BookmarkData,
-  S extends z.ZodSchema<T> = z.ZodSchema<T>,
->(
-  schema?: S,
-) => {
-  // No payload schema was supplied — fall back to accepting any JSON-serializable value.
-  // The generic constraint `S extends z.ZodSchema<T>` can't express this default directly,
-  // so the fallback schema must be cast through `unknown` to satisfy `S`.
-  const payloadSchema =
-    schema ?? (z.record(z.string(), z.unknown()).or(z.string()).optional() as unknown as S);
-  return bookmarkSchema.extend({
-    payload: payloadSchema,
-  });
-};
-
-/**
- * Parses an unknown value into a typed {@link Bookmark} using {@link bookmarkWithDataSchema}.
- *
- * @template T - The bookmark payload data shape.
- * @param value - The raw value to parse.
- * @returns The parsed bookmark object.
- * @throws {ZodError} When validation fails.
- */
-export const parseBookmark = <T extends BookmarkData>(value: unknown): Bookmark<T> => {
-  return bookmarkWithDataSchema().parse(value) as Bookmark<T>;
-};

package/src/create-bookmark-reducer.ts

@@ -1,149 +0,0 @@
-import {
-  createReducer,
-  getBaseType,
-  isCompleteAction,
-  isFailureAction,
-  isRequestAction,
-  isSuccessAction,
-  type ActionBaseType,
-} from '@equinor/fusion-observable';
-
-import { bookmarkActions, type BookmarkActions } from './bookmark-actions';
-import type { BookmarkState } from './create-bookmark-store';
-import type { BookmarkFlowError } from './BookmarkFlowError';
-import type { BookmarkWithoutData } from './types';
-import { enableMapSet } from 'immer';
-
-enableMapSet();
-
-/**
- * Utility function that extracts the base action type from a given action object.
- */
-const getBookmarkBaseAction = <T extends BookmarkActions>(action: T): ActionBaseType<T> => {
-  return getBaseType(action.type) as ActionBaseType<T>;
-};
-
-/**
- * The default initial state for the BookmarkProvider reducer.
- */
-const defaultInitialState: BookmarkState = {
-  status: new Set<ActionBaseType<BookmarkActions>>(),
-  errors: {} as Record<ActionBaseType<BookmarkActions>, BookmarkFlowError>,
-  bookmarks: {},
-};
-
-/**
- * Creates a reducer for managing the state of bookmarks.
- *
- * @todo TODO(#5135) - add fast-deep-equal to compare bookmarks
- *
- * @param initialState - The initial state of the bookmarks.
- * @returns A reducer function for managing the bookmarks state.
- */
-export const createBookmarkReducer = (initialState?: Partial<BookmarkState>) => {
-  // Layer any provided overrides on top of the module's defaults for the initial state.
-  const initial = { ...defaultInitialState, ...initialState };
-  return createReducer<BookmarkState, BookmarkActions>(initial, (builder) => {
-    builder
-      .addCase(bookmarkActions.fetchBookmark.success, (state, action) => {
-        // only update the bookmark if it already exists in the store
-        if (action.payload.id in state.bookmarks) {
-          state.bookmarks[action.payload.id] = action.payload;
-        }
-      })
-      .addCase(bookmarkActions.fetchBookmarkData.success, (state, action) => {
-        const { bookmarkId, data } = action.payload;
-        // only apply the fetched data if it belongs to the current bookmark
-        if (state.currentBookmark?.id === bookmarkId) {
-          state.currentBookmark.payload = data;
-        }
-      })
-      .addCase(bookmarkActions.fetchBookmarks.success, (state, action) => {
-        // normalize the bookmarks array into a record
-        // build a lookup record keyed by bookmark id
-        state.bookmarks = action.payload.reduce(
-          (acc, bookmark) => {
-            acc[bookmark.id] = bookmark;
-            return acc;
-          },
-          {} as Record<string, BookmarkWithoutData>,
-        );
-      })
-      .addCase(bookmarkActions.setBookmark, (state, action) => {
-        const bookmarkId = action.payload.id;
-        // only update the bookmark if it already exists in the store
-        if (bookmarkId in state.bookmarks) {
-          state.bookmarks[bookmarkId] = action.payload;
-        }
-        // keep the current bookmark in sync if it's the one being set
-        if (state.currentBookmark?.id === bookmarkId) {
-          state.currentBookmark = action.payload;
-        }
-      })
-      .addCase(bookmarkActions.setCurrentBookmark, (state, action) => {
-        state.currentBookmark = action.payload;
-      })
-      .addCase(bookmarkActions.createBookmark.success, (state, action) => {
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        const { payload, ...bookmark } = action.payload;
-        state.bookmarks[bookmark.id] = bookmark;
-      })
-      .addCase(bookmarkActions.updateBookmark.success, (state, action) => {
-        const bookmarkId = action.payload.id;
-        const hasBookmark = bookmarkId in state.bookmarks;
-        const isCurrent = state.currentBookmark?.id === bookmarkId;
-
-        // get the current bookmark
-        const current = hasBookmark
-          ? state.bookmarks[bookmarkId]
-          : isCurrent
-            ? state.currentBookmark
-            : null;
-
-        // merge the current bookmark with the new data
-        const next = { ...current, ...action.payload };
-
-        // if the bookmark is in the current state, update it
-        if (hasBookmark) {
-          state.bookmarks[bookmarkId] = next;
-        }
-
-        // if the bookmark is the selected bookmark, update it
-        if (isCurrent) {
-          state.currentBookmark = next;
-        }
-      })
-
-      /** removal of bookmarks */
-      .addCase(bookmarkActions.deleteBookmark.success, (state, action) => {
-        delete state.bookmarks[action.payload];
-      })
-      .addCase(bookmarkActions.removeBookmarkAsFavourite.success, (state, action) => {
-        delete state.bookmarks[action.payload];
-      })
-
-      /** when a request is made, add the action type to the status object */
-      .addMatcher(isRequestAction, (state, action) => {
-        const actionName = getBookmarkBaseAction(action);
-        state.status.add(actionName);
-      })
-
-      /** when a request succeeds, remove the error from the errors object */
-      .addMatcher(isSuccessAction, (state, action) => {
-        const actionName = getBookmarkBaseAction(action);
-        delete state.errors[actionName];
-      })
-
-      /** when a request fails, add the error to the errors object */
-      .addMatcher(isFailureAction, (state, action) => {
-        const actionName = getBookmarkBaseAction(action);
-        state.errors[actionName] = action.payload;
-      })
-
-      /** when a request is complete, remove the status from the status set */
-      .addMatcher(isCompleteAction, (state, action) => {
-        const actionName = getBookmarkBaseAction(action);
-        state.status.delete(actionName);
-      });
-  });
-};