feat(context): add support for custom context path extraction and generation

Author: odinr

.changeset/sad-trains-fix.md

@@ -0,0 +1,52 @@
+---
+"@equinor/fusion-framework-module-context": minor
+"@equinor/fusion-framework-cli": minor
+---
+
+**@equinor/fusion-framework-react:**
+
+- Enhanced `useAppContextNavigation` to support custom context path extraction and generation. This allows for more flexible navigation handling based on application-specific requirements.
+
+**@equinor/fusion-framework-module-context:**
+
+- Added support for custom context path extraction and generation in `ContextConfigBuilder`, `ContextProvider`, and `ContextModuleConfigurator`.
+- Introduced `setContextPathExtractor` and `setContextPathGenerator` methods in `ContextConfigBuilder` to allow developers to define custom logic for extracting and generating context paths.
+- Updated `ContextProvider` to utilize `extractContextIdFromPath` and `generatePathFromContext` from the configuration, enabling dynamic path handling.
+- Enhanced `ContextModuleConfigurator` to include `extractContextIdFromPath` and `generatePathFromContext` in the module configuration.
+
+If you are using `@equinor/fusion-framework-module-context` and need custom logic for context path handling:
+
+1. Use `setContextPathExtractor` to define how to extract context IDs from paths.
+2. Use `setContextPathGenerator` to define how to generate paths based on context items.
+
+Example:
+
+```typescript
+builder.setContextPathExtractor((path) => {
+  // Custom logic to extract context ID from path
+  return path.match(/\/custom\/(.+)/)?.[1];
+});
+
+builder.setContextPathGenerator((context, path) => {
+  // Custom logic to generate path from context
+  return path.replace(/^(\/)?custom\/[^/]+(.*)$/, `/app/${item.id}$2`);
+});
+```
+
+If your portal is generating context paths based on context items, you can now define custom logic for context path handling:
+
+```typescript
+contextProvider.currentContext$
+  .pipe(
+    map((context) => {
+      // Custom logic to generate path from context
+      const path = contextProvider.generatePathFromContext?.(
+        context,
+        location.pathname
+      );
+      return path ?? fallbackPathGenerator(context, location.pathname);
+    }),
+    filter(Boolean)
+  )
+  .subscribe((path) => history.push(path));
+```

packages/cli/src/bin/dev-portal/useAppContextNavigation.ts

@@ -64,13 +64,16 @@ export const useAppContextNavigation = () => {
         }
 
         // extract the context id from the current path
-        const pathContextId = extractContextIdFromPath(currentPathname);
+        const pathContextId =
+          context?.extractContextIdFromPath?.(currentPathname) ??
+          extractContextIdFromPath(currentPathname);
 
         // generate path to the selected context
         const pathname = pathContextId
           ? item
             ? // context id exists in the url, replace it with the new context id
-              currentPathname.replace(pathContextId, item.id)
+              (context?.generatePathFromContext?.(item, currentPathname) ??
+              currentPathname.replace(pathContextId, item.id))
             : // context was cleared, set the path to the root
               '/'
           : // could not find context id in the url, set the path to the new context id
@@ -87,7 +90,10 @@ export const useAppContextNavigation = () => {
         // if app has its own navigation, use it to navigate
         if (appNavigation) {
           // update the path of the app navigation, preserving search and hash
-          appNavigation.replace({ ...appNavigation.path, pathname });
+          appNavigation.replace({
+            ...appNavigation.path,
+            pathname,
+          });
         } else {
           // update the path of the portal navigation, preserving search and hash
           navigation.replace({ ...navigation.path, pathname });

packages/modules/context/src/ContextConfigBuilder.ts

@@ -74,6 +74,25 @@ export class ContextConfigBuilder<
     this.config.resolveContext = fn;
   }
 
+  /**
+   * Sets the function responsible for extracting the context ID from a given path.
+   *
+   * @param fn - A function that defines how to extract the context ID from a path.
+   *             This function should match the type defined in `ContextModuleConfig['extractContextIdFromPath']`.
+   */
+  setContextPathExtractor(fn: ContextModuleConfig['extractContextIdFromPath']) {
+    this.config.extractContextIdFromPath = fn;
+  }
+
+  /**
+   * Sets the function responsible for generating a path from the context.
+   *
+   * @param fn - A function that takes a context and generates a corresponding path.
+   */
+  setContextPathGenerator(fn: ContextModuleConfig['generatePathFromContext']) {
+    this.config.generatePathFromContext = fn;
+  }
+
   setResolveInitialContext(fn: ContextModuleConfig['resolveInitialContext']) {
     this.config.resolveInitialContext = fn;
   }

packages/modules/context/src/ContextProvider.ts

@@ -138,6 +138,23 @@ export interface IContextProvider {
     context: ContextItem<Record<string, unknown>> | null,
     opt?: { validate?: boolean; resolve?: boolean },
   ): Promise<ContextItem<Record<string, unknown>> | null>;
+
+  /**
+   * Method for extracting context id from a path.
+   *
+   * @param path path to resolve context from
+   * @returns the resolved context item id
+   */
+  extractContextIdFromPath?: (path: string) => string | undefined;
+
+  /**
+   * Method for generating path from a context item.
+   *
+   * @param context context item to generate path from
+   * @param path current path
+   * @returns path for the context item
+   */
+  generatePathFromContext?: (context: ContextItem, path: string) => string | undefined;
 }
 
 export class ContextProvider implements IContextProvider {
@@ -205,6 +222,15 @@ export class ContextProvider implements IContextProvider {
     config.resolveContext && (this.resolveContext = config.resolveContext?.bind(this));
     config.validateContext && (this.validateContext = config.validateContext?.bind(this));
 
+    if (config.extractContextIdFromPath) {
+      // @ts-ignore
+      this.extractContextIdFromPath = config.extractContextIdFromPath;
+    }
+    if (config.generatePathFromContext) {
+      // @ts-ignore
+      this.generatePathFromContext = config.generatePathFromContext;
+    }
+
     this.#contextType = config.contextType;
     this.#contextFilter = config.contextFilter;
 

packages/modules/context/src/configurator.ts

@@ -40,6 +40,9 @@ export interface ContextModuleConfig {
   /** set initial context from parent, will await resolve */
   skipInitialContext?: boolean;
 
+  extractContextIdFromPath?: (path: string) => string | undefined;
+  generatePathFromContext?: (context: ContextItem, path: string) => string | undefined;
+
   /**
    * Method for generating context query parameters.
    */
@@ -105,7 +108,14 @@ export class ContextModuleConfigurator implements IContextModuleConfigurator {
       Promise.resolve({} as Partial<ContextModuleConfig>),
     );
 
-    config.resolveInitialContext ??= resolveInitialContext();
+    console.log(999, 'createConfig', config);
+
+    config.resolveInitialContext ??= resolveInitialContext({
+      path: {
+        extract: config.extractContextIdFromPath,
+        validate: config.extractContextIdFromPath ? () => true : undefined,
+      },
+    });
 
     // TODO - make less lazy
     config.client ??= await (async (): Promise<ContextModuleConfig['client']> => {