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

package/src/BookmarkClient.interface.ts

@@ -1,157 +0,0 @@
-import type { ObservableInput } from 'rxjs';
-import type { Bookmark, BookmarkData, BookmarkWithoutData } from './types';
-
-/**
- * Defines the shape of a filter for querying bookmarks.
- * @property {string} [appKey] - The app key to filter bookmarks by.
- * @property {string} [contextId] - The context ID to filter bookmarks by.
- * @property {object} [sourceSystem] - The source system to filter bookmarks by.
- * @property {string} [sourceSystem.identifier] - The identifier of the source system.
- * @property {string} [sourceSystem.name] - The name of the source system.
- * @property {string} [sourceSystem.subSystem] - The sub-system of the source system.
- */
-export type BookmarksFilter = {
-  appKey?: string;
-  contextId?: string;
-  sourceSystem?: {
-    identifier?: string;
-    name?: string | null;
-    subSystem?: string | null;
-  };
-};
-
-/**
- * Defines the shape of an update to an existing bookmark.
- * @template T - The type of the payload data for the bookmark.
- * @property {string} [name] - The updated name of the bookmark.
- * @property {string} [description] - The updated description of the bookmark.
- * @property {boolean} [isShared] - Whether the bookmark is shared or not.
- * @property {T} [payload] - The updated payload data for the bookmark.
- */
-export type BookmarkUpdate<T extends BookmarkData = BookmarkData> = {
-  name?: string;
-  description?: string;
-  isShared?: boolean;
-  payload?: T | null;
-  sourceSystem?: {
-    identifier: string;
-    name?: string | null;
-    subSystem?: string | null;
-  } | null;
-};
-
-/**
- * Defines the shape of a new bookmark to be created.
- * @template T - The type of the payload data for the bookmark.
- * @property {string} name - The name of the bookmark.
- * @property {string} appKey - The app key associated with the bookmark.
- * @property {string} [description] - The description of the bookmark.
- * @property {boolean} [isShared] - Whether the bookmark is shared or not.
- * @property {string} [contextId] - The context ID associated with the bookmark.
- * @property {object} [sourceSystem] - Information about the source system of the bookmark.
- * @property {string} [sourceSystem.identifier] - The identifier of the source system.
- * @property {string} [sourceSystem.name] - The name of the source system.
- * @property {string} [sourceSystem.subSystem] - The sub-system of the source system.
- * @property {T} [payload] - The payload data for the bookmark.
- */
-export type BookmarkNew<T extends BookmarkData = BookmarkData> = {
-  name: string;
-  appKey: string;
-  description?: string;
-  isShared?: boolean;
-  contextId?: string;
-  sourceSystem?: {
-    identifier: string;
-    name?: string;
-    subSystem?: string;
-  };
-  payload?: T;
-};
-
-/**
- * Defines the interface for a Bookmarks client, which provides methods for managing bookmarks.
- */
-export interface IBookmarkClient {
-  /**
-   * Retrieves all bookmarks for the current user.
-   * @template TPayload - The type of the payload data for the bookmarks.
-   * @param args - Optional arguments to filter or customize the bookmark retrieval.
-   * @returns An observable input containing an array of bookmarks.
-   */
-  getAllBookmarks: (filter?: BookmarksFilter) => ObservableInput<Array<Bookmark>>;
-
-  /**
-   * Retrieves a single bookmark by id.
-   * @template TPayload - The type of the payload data for the bookmark.
-   * @param bookmarkId - The id of the bookmark to retrieve.
-   * @returns An observable input containing the requested bookmark.
-   */
-  getBookmarkById: (bookmarkId: string) => ObservableInput<BookmarkWithoutData>;
-
-  /**
-   * Retrieves the bookmark data for the specified bookmark ID.
-   *
-   * @param bookmarkId - The ID of the bookmark to retrieve data for.
-   * @returns An observable that emits the bookmark data.
-   */
-  getBookmarkData: <T extends BookmarkData>(bookmarkId: string) => ObservableInput<T>;
-
-  /**
-   * Updates the data associated with a bookmark.
-   *
-   * @template T - The type of the data to be associated with the bookmark. Can be a record or null.
-   * @param bookmarkId - The ID of the bookmark to update.
-   * @param data - The new data to be associated with the bookmark.
-   * @returns An observable that emits the updated data.
-   */
-  setBookmarkData<T extends BookmarkData | null>(bookmarkId: string, data: T): ObservableInput<T>;
-
-  /**
-   * Adds a bookmark to the current user's favorites.
-   * @param bookmarkId - The id of the bookmark to add to favorites.
-   * @returns An observable input containing a boolean indicating whether the operation was successful.
-   */
-  addBookmarkToFavorites: (bookmarkId: string) => ObservableInput<boolean>;
-
-  /**
-   * Removes a bookmark from the current user's favorites.
-   * @param bookmarkId - The id of the bookmark to remove from favorites.
-   * @returns An observable input containing a boolean indicating whether the operation was successful.
-   */
-  removeBookmarkFromFavorites: (bookmarkId: string) => ObservableInput<boolean>;
-
-  /**
-   * Verifies whether a bookmark is a favorite of the current user.
-   * @param bookmarkId - The id of the bookmark to verify.
-   * @returns An observable input containing a boolean indicating whether the bookmark is a favorite.
-   */
-  isBookmarkFavorite: (bookmarkId: string) => ObservableInput<boolean>;
-
-  /**
-   * Creates a new bookmark.
-   * @template TPayload - The type of the payload data for the bookmark.
-   * @param bookmark - The bookmark data to create.
-   * @returns An observable input containing the created bookmark.
-   */
-  createBookmark: <T extends BookmarkData>(
-    bookmark: BookmarkNew<T>,
-  ) => ObservableInput<Bookmark<T>>;
-
-  /**
-   * Updates an existing bookmark.
-   * @template TPayload - The type of the payload data for the bookmark.
-   * @param bookmark - The bookmark data to update.
-   * @returns An observable input containing the updated bookmark.
-   */
-  updateBookmark: <T extends BookmarkData>(
-    bookmarkId: string,
-    updates: BookmarkUpdate<T>,
-  ) => ObservableInput<Bookmark<T>>;
-
-  /**
-   * Deletes a bookmark by id.
-   * @param bookmarkId - The id of the bookmark to delete.
-   * @returns An observable input containing a boolean indicating whether the operation was successful.
-   */
-  deleteBookmark: (bookmarkId: string) => ObservableInput<boolean>;
-}

package/src/BookmarkClient.ts

@@ -1,290 +0,0 @@
-import { Observable, type ObservableInput } from 'rxjs';
-import { map, shareReplay, tap } from 'rxjs/operators';
-
-/**
- * Imports the `Query` type from the `@equinor/fusion-query` package.
- * This type is used to cache the results of API requests.
- */
-import { Query } from '@equinor/fusion-query';
-
-/**
- * Imports the `BookmarksApiClient` and `ApiBookmarkEntityV1` types from the `@equinor/fusion-framework-module-services/bookmarks` package.
- * These types are used to interact with the Fusion Bookmarks API and represent the API response entities.
- */
-import {
-  type BookmarksApiClient,
-  type ApiBookmarkSchema,
-  ApiPersonSchema,
-  type ApiVersion,
-} from '@equinor/fusion-framework-module-services/bookmarks';
-
-import type {
-  IBookmarkClient,
-  BookmarksFilter,
-  BookmarkNew,
-  BookmarkUpdate,
-} from './BookmarkClient.interface';
-
-import type { Bookmark, BookmarkData, BookmarkWithoutData, Bookmarks, BookmarkUser } from './types';
-import { bookmarkWithDataSchema } from './bookmark.schemas';
-import type { z } from 'zod';
-
-// Define the schema for the API response entity representing a bookmark
-const UserSchema = ApiPersonSchema['1.0'].transform((person) => {
-  return {
-    // @deprecated
-    azureUniqueId: person.azureUniqueId,
-    id: person.azureUniqueId,
-    name: person.name,
-    email: person.mail,
-  } as BookmarkUser;
-});
-
-// Parse the bookmark entity from the API response
-const parseBookmark = <T extends BookmarkData>(value: unknown): Bookmark<T> => {
-  const { createdBy, updatedBy, ...rest } = value as z.infer<
-    (typeof ApiBookmarkSchema)[ApiVersion.v2]
-  >;
-  return bookmarkWithDataSchema().parse({
-    ...rest,
-    createdBy: UserSchema.parse(createdBy),
-    updatedBy: updatedBy ? UserSchema.parse(updatedBy) : undefined,
-  }) as Bookmark<T>;
-};
-
-const parseBookmarkWithoutPayload = (value: unknown): BookmarkWithoutData => {
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  const { payload, ...bookmark } = parseBookmark(value);
-  return bookmark;
-};
-
-/**
- * Represents a client for interacting with the Fusion Bookmarks API.
- * This class provides methods for retrieving, creating, updating, and deleting bookmarks, as well as managing favorites.
- *
- * This implementation consumes the `@equinor/fusion-framework-module-services/bookmarks` package.
- * This is the default implementation of the bookmarks API client.
- *
- * This class is intended to be used by the Fusion framework with the Fusion Core Services (Backend)
- *
- * Fetching single and all bookmarks will use Query from '@equinor/fusion-query' to cache the results.
- *
- * @remarks if you wish to implement your own bookmarks API client, you can do so by implementing the {@link IBookmarkClient} interface.
- */
-export class BookmarkClient implements IBookmarkClient {
-  #api: BookmarksApiClient<'json$'>;
-
-  #queryBookmark: Query<BookmarkWithoutData, { bookmarkId: string }>;
-  #queryBookmarks: Query<Bookmarks, BookmarksFilter | undefined>;
-  #queryBookmarkData: Query<BookmarkData | undefined, { bookmarkId: string }>;
-
-  /**
-   * Constructs a new `BookmarkClient` instance with the provided `BookmarksApiClient`.
-   *
-   * @param api - The `BookmarksApiClient` instance to use for making API requests.
-   * @param options - Optional client options, such as the cache expiry time.
-   */
-  constructor(api: BookmarksApiClient<'json$'>, options?: { expire?: number }) {
-    this.#api = api;
-
-    const { expire = 5 * 60 * 1000 } = options ?? {};
-
-    // set up the query for fetching a single bookmark
-    this.#queryBookmark = new Query({
-      client: {
-        fn: (args: { bookmarkId: string }) => {
-          // strip the payload from the fetched bookmark before caching
-          return this.#api.get('v2', args).pipe(map(parseBookmarkWithoutPayload));
-        },
-      },
-      key: (args) => args.bookmarkId,
-      expire,
-    });
-
-    // set up the query for fetching all bookmarks
-    this.#queryBookmarks = new Query({
-      client: {
-        fn: (filter?: BookmarksFilter) => {
-          // strip the payload from each fetched bookmark before caching
-          return this.#api.query('v2', { filter }).pipe(
-            map((res) =>
-              // strip the payload field from each bookmark
-              res.map(parseBookmarkWithoutPayload),
-            ),
-          );
-        },
-      },
-      key: (args) => JSON.stringify(args ?? ''),
-      expire,
-    });
-
-    this.#queryBookmarkData = new Query({
-      client: {
-        fn: (args: { bookmarkId: string }) => {
-          // extract only the payload from the API response
-          return this.#api.getPayload('v1', args).pipe(map((res) => res.payload));
-        },
-      },
-      key: (args) => args.bookmarkId,
-      expire,
-      cache: {
-        trimming: {
-          size: 3,
-        },
-      },
-    });
-  }
-
-  /** @inheritdoc */
-  public getAllBookmarks(filter?: BookmarksFilter): ObservableInput<Bookmark[]> {
-    // unwrap the query result value
-    return this.#queryBookmarks.query(filter).pipe(map((res) => res.value as Bookmark[]));
-  }
-
-  /** @inheritdoc */
-  public getBookmarkById(bookmarkId: string): ObservableInput<BookmarkWithoutData> {
-    // unwrap the query result value
-    return this.#queryBookmark.query({ bookmarkId }).pipe(map((res) => res.value));
-  }
-
-  /** @inheritdoc */
-  public getBookmarkData<T extends BookmarkData>(bookmarkId: string): ObservableInput<T> {
-    // unwrap the query result value
-    return this.#queryBookmarkData.query({ bookmarkId }).pipe(map((res): T => res.value as T));
-  }
-
-  /** @inheritdoc */
-  public setBookmarkData<T extends BookmarkData | null>(
-    bookmarkId: string,
-    data: T,
-  ): ObservableInput<T> {
-    // update the payload cache once the mutation succeeds
-    return this.#api.patch('v1', { bookmarkId, updates: { payload: data } }).pipe(
-      map((res) => res.payload as T),
-      tap((updatedData) => {
-        // only update the cache when data was actually returned
-        if (updatedData) {
-          this.#queryBookmarkData.mutate(
-            { bookmarkId },
-            { value: updatedData, updated: Date.now() },
-            { allowCreation: true },
-          );
-        }
-      }),
-    );
-  }
-
-  /** @inheritdoc */
-  public createBookmark<T extends BookmarkData>(
-    newBookmark: BookmarkNew<T>,
-  ): ObservableInput<Bookmark<T>> {
-    // parse the response and update caches once the bookmark is created
-    return this.#api.create('v1', newBookmark).pipe(
-      map((response) => parseBookmark<T>(response)),
-      /** update the bookmark cache */
-      tap((createdBookmark) => {
-        console.log('createdBookmark', createdBookmark);
-        const { payload, ...bookmark } = createdBookmark;
-        this.#queryBookmark.mutate(
-          { bookmarkId: bookmark.id },
-          { value: bookmark, updated: Date.now() },
-          { allowCreation: true },
-        );
-        // only cache the payload if the created bookmark has one
-        if (payload) {
-          this.#queryBookmarkData.mutate(
-            { bookmarkId: bookmark.id },
-            { value: payload, updated: Date.now() },
-            { allowCreation: true },
-          );
-        }
-        this.#queryBookmarks.invalidate();
-      }),
-    );
-  }
-
-  /** @inheritdoc */
-  public updateBookmark<T extends BookmarkData>(
-    bookmarkId: string,
-    updates: BookmarkUpdate<T>,
-  ): ObservableInput<Bookmark<T>> {
-    // parse the response and share it across the cache-update subscriptions below
-    const update$ = this.#api.patch('v1', { bookmarkId, updates: updates }).pipe(
-      map((response) => parseBookmark<T>(response)),
-      shareReplay(),
-    );
-    return new Observable((subscriber) => {
-      // update the query cache for the specific bookmark
-      subscriber.add(
-        update$.subscribe((updatedBookmark) => {
-          const { payload, ...bookmark } = updatedBookmark;
-          // payload should not be included in the bookmark object
-          payload;
-          this.#queryBookmark.mutate(
-            { bookmarkId },
-            { value: bookmark, updated: Date.now() },
-            { allowCreation: false },
-          );
-        }),
-      );
-
-      // update the cache for bookmark data
-      subscriber.add(
-        update$.subscribe((updatedBookmark) => {
-          const { payload } = updatedBookmark;
-          // only cache the payload when present, otherwise clear any stale cache entry
-          if (payload) {
-            this.#queryBookmarkData.mutate(
-              {
-                bookmarkId: updatedBookmark.id,
-              },
-              { value: payload, updated: Date.now() },
-              { allowCreation: true },
-            );
-          } else {
-            const cacheKey = this.#queryBookmarkData.generateCacheKey({
-              bookmarkId: updatedBookmark.id,
-            });
-            this.#queryBookmarkData.cache.removeItem(cacheKey);
-          }
-        }),
-      );
-
-      // invalidate the bookmarks query cache
-      subscriber.add(
-        update$.subscribe(() => {
-          this.#queryBookmarks.invalidate();
-        }),
-      );
-
-      // emit the update to the subscriber
-      update$.subscribe(subscriber);
-    });
-  }
-
-  /** @inheritdoc */
-  public deleteBookmark(bookmarkId: string): ObservableInput<boolean> {
-    return this.#api.delete('v1', { bookmarkId });
-  }
-
-  /** @inheritdoc */
-  public addBookmarkToFavorites(bookmarkId: string): ObservableInput<boolean> {
-    // invalidate the bookmarks list cache once favorited
-    return this.#api
-      .addFavourite('v1', { bookmarkId })
-      .pipe(tap(() => this.#queryBookmarks.invalidate()));
-  }
-
-  /** @inheritdoc */
-  public removeBookmarkFromFavorites(bookmarkId: string): ObservableInput<boolean> {
-    // invalidate the bookmarks list cache once unfavorited
-    return this.#api
-      .removeFavourite('v1', { bookmarkId })
-      .pipe(tap(() => this.#queryBookmarks.invalidate()));
-  }
-
-  /** @inheritdoc */
-  public isBookmarkFavorite(bookmarkId: string): ObservableInput<boolean> {
-    return this.#api.isFavorite('v1', { bookmarkId });
-  }
-}

package/src/BookmarkFlowError.ts

@@ -1,38 +0,0 @@
-import type { ActionWithSuffix } from '@equinor/fusion-observable';
-
-import type { BookmarkActions } from './bookmark-actions';
-
-/**
- * Error thrown inside bookmark store flows (side-effect pipelines) when an
- * API call or observable chain fails.
- *
- * Carries a reference to the originating request action so callers can
- * correlate errors back to specific operations.
- */
-export class BookmarkFlowError extends Error {
-  /**
-   * Constructs a new `BookmarkFlowError`.
-   *
-   * @param message - Human-readable error message.
-   * @param action - The request action that triggered the failed flow.
-   * @param options - Optional `ErrorOptions` (e.g. `cause`).
-   */
-  constructor(
-    message: string,
-    /** The request action that triggered the failed flow. */
-    public readonly action: ActionWithSuffix<BookmarkActions, 'request'>,
-    options?: ErrorOptions,
-  ) {
-    super(message, options);
-    this.name = 'BookmarkProcessError';
-  }
-}
-
-/**
- * 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 { BookmarkProviderError } from './BookmarkProviderError';