@equinor/fusion-framework-module-bookmark 2.2.1 → 3.0.1

package/src/bookmark-config.schema.ts

@@ -8,6 +8,7 @@ import type { IBookmarkProvider } from './BookmarkProvider.interface';
 import type { IBookmarkClient } from './BookmarkClient.interface';
 
 import { bookmarkSourceSystemSchema } from './bookmark.schemas';
+import type { BookmarkModuleConfig } from './types';
 
 export const bookmarkConfigSchema = z.object({
   log: z.custom<ILogger>().optional(),
@@ -20,12 +21,8 @@ export const bookmarkConfigSchema = z.object({
   client: z.custom<IBookmarkClient>().describe('API client for interacting with bookmarks'),
   resolve: z
     .object({
-      context: z.function().returns(z.promise(z.object({ id: z.string() }).optional())),
-      application: z
-        .function()
-        .returns(
-          z.promise(z.object({ appKey: z.string(), name: z.string().optional() }).optional()),
-        ),
+      context: z.function(),
+      application: z.function(),
     })
     .describe('Functions for resolving context and application'),
   filters: z
@@ -37,3 +34,7 @@ export const bookmarkConfigSchema = z.object({
     .optional()
     .default({ context: false, application: false }),
 });
+
+export const parseBookmarkConfig = (config: unknown): BookmarkModuleConfig => {
+  return bookmarkConfigSchema.parse(config) as BookmarkModuleConfig;
+};

package/src/bookmark.schemas.ts

@@ -1,5 +1,5 @@
 import * as z from 'zod';
-import type { BookmarkData } from './types';
+import type { Bookmark, BookmarkData } from './types';
 
 export const bookmarkUserSchema = z.object({
   id: z.string(),
@@ -42,8 +42,12 @@ export const bookmarkWithDataSchema = <
   T extends BookmarkData = BookmarkData,
   S extends z.ZodSchema<T> = z.ZodSchema<T>,
 >(
-  schema: S = z.record(z.unknown()).or(z.string()).optional() as unknown as S,
+  schema: S = z.record(z.string(), z.unknown()).or(z.string()).optional() as unknown as S,
 ) =>
   bookmarkSchema.extend({
     payload: schema,
   });
+
+export const parseBookmark = <T extends BookmarkData>(value: unknown): Bookmark<T> => {
+  return bookmarkWithDataSchema().parse(value) as Bookmark<T>;
+};

package/src/types.ts

@@ -1,57 +1,121 @@
-import type z from 'zod';
-
-import type {
-  bookmarkContextSchema,
-  bookmarkSchema,
-  bookmarkSourceSystemSchema,
-  bookmarksSchema,
-  bookmarkUserSchema,
-} from './bookmark.schemas';
-
-import type { bookmarkConfigSchema } from './bookmark-config.schema';
+import type { ILogger, LogLevel } 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';
 
 /**
  * Represents the source system for a bookmark.
  */
-export type SourceSystem = z.infer<typeof bookmarkSourceSystemSchema>;
+export interface SourceSystem {
+  /** Unique identifier for the source system */
+  identifier: string;
+  /** Human-readable name of the source system */
+  name?: string | null;
+  /** Sub-system identifier */
+  subSystem?: string | null;
+}
 
 /**
  * Represents the data associated with a bookmark.
  * This is a generic type that can hold any arbitrary data as a key-value map.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type BookmarkData = Record<string, any> | string;
+export type BookmarkData = Record<string, unknown> | string;
 
 /**
- * Represents a collection of bookmarks.
+ * Represents a user associated with a bookmark.
+ */
+export interface BookmarkUser {
+  /** Unique identifier for the user */
+  id: string;
+  /** Display name of the user */
+  name: string;
+  /** Email address of the user */
+  mail?: string;
+}
+
+/**
+ * Represents the context associated with a bookmark.
  */
-export type Bookmarks = z.infer<typeof bookmarksSchema>;
+export interface BookmarkContext {
+  /** Unique identifier for the context */
+  id: string;
+  /** Human-readable name of the context */
+  name?: string;
+  /** Type of the context */
+  type?: string;
+}
 
 /**
  * Represents a bookmark without any associated data.
  */
-export type BookmarkWithoutData = z.infer<typeof bookmarkSchema>;
+export interface BookmarkWithoutData {
+  /** Unique identifier for the bookmark */
+  id: string;
+  /** Name of the bookmark */
+  name: string;
+  /** Application key this bookmark belongs to */
+  appKey: string;
+  /** Optional description of the bookmark */
+  description?: string;
+  /** Whether the bookmark is shared */
+  isShared?: boolean;
+  /** When the bookmark was created */
+  created: Date;
+  /** User who created the bookmark */
+  createdBy: BookmarkUser;
+  /** When the bookmark was last updated */
+  updated?: Date;
+  /** User who last updated the bookmark */
+  updatedBy?: BookmarkUser;
+  /** Context associated with the bookmark */
+  context?: BookmarkContext;
+  /** Source system information */
+  sourceSystem?: SourceSystem | null;
+}
 
 /**
  * Represents a bookmark with associated data.
  * @template T - The type of the bookmark data.
  */
 // biome-ignore lint/suspicious/noExplicitAny: must be any to support all bookmark data types
-export type Bookmark<T extends BookmarkData = any> = BookmarkWithoutData & {
+export interface Bookmark<T extends BookmarkData = any> extends BookmarkWithoutData {
+  /** Optional payload data associated with the bookmark */
   payload?: T;
-};
+}
 
 /**
- * Represents the configuration options for a bookmark module.
- */
-export type BookmarkModuleConfig = z.infer<typeof bookmarkConfigSchema>;
-
-/**
- * Represents a user associated with a bookmark.
+ * Represents a collection of bookmarks.
  */
-export type BookmarkUser = z.infer<typeof bookmarkUserSchema>;
+export type Bookmarks = BookmarkWithoutData[];
 
 /**
- * Represents the context associated with a bookmark.
+ * Represents the configuration options for a bookmark module.
  */
-export type bookmarkContext = z.infer<typeof bookmarkContextSchema>;
+export interface BookmarkModuleConfig {
+  /** Optional logger instance */
+  log?: ILogger;
+  /** Optional log level */
+  logLevel?: LogLevel;
+  /** Optional event provider for handling events */
+  eventProvider?: IEventModuleProvider;
+  /** The source system for the bookmarks */
+  sourceSystem?: SourceSystem;
+  /** Parent Bookmark provider */
+  parent?: IBookmarkProvider | null;
+  /** API client for interacting with bookmarks */
+  client: IBookmarkClient;
+  /** Functions for resolving context and application */
+  resolve: {
+    /** Function to resolve the current context */
+    context: () => Promise<{ id: string } | undefined>;
+    /** Function to resolve the current application */
+    application: () => Promise<{ appKey: string; name?: string } | undefined>;
+  };
+  /** Flags for enabling resolving when fetching bookmarks */
+  filters?: {
+    /** Whether to filter by context */
+    context?: boolean;
+    /** Whether to filter by application */
+    application?: boolean;
+  };
+}

package/src/version.ts

@@ -1,2 +1,2 @@
 // Generated by genversion.
-export const version = '2.2.1';
+export const version = '3.0.1';