@equinor/fusion-framework-module-context 0.0.0-context-error-20240131144633

package/src/configurator.ts

@@ -0,0 +1,158 @@
+import { ObservableInput } from 'rxjs';
+
+import {
+    AnyModuleInstance,
+    ModuleInitializerArgs,
+    ModuleInstance,
+    ModulesInstanceType,
+} from '@equinor/fusion-framework-module';
+import { ServicesModule, IApiProvider } from '@equinor/fusion-framework-module-services';
+import { NavigationModule } from '@equinor/fusion-framework-module-navigation';
+import { getContextSelector, queryContextSelector, relatedContextSelector } from './selectors';
+import { QueryCtorOptions } from '@equinor/fusion-query';
+import {
+    ContextFilterFn,
+    ContextItem,
+    QueryContextParameters,
+    RelatedContextParameters,
+} from './types';
+import { GetContextParameters } from './client/ContextClient';
+import { ContextConfigBuilder, ContextConfigBuilderCallback } from './ContextConfigBuilder';
+import { type IContextProvider } from './ContextProvider';
+import resolveInitialContext from './utils/resolve-initial-context';
+
+export interface ContextModuleConfig {
+    client: {
+        get: QueryCtorOptions<ContextItem, GetContextParameters>;
+        query: QueryCtorOptions<ContextItem[], QueryContextParameters>;
+        related?: QueryCtorOptions<ContextItem[], RelatedContextParameters>;
+    };
+    contextType?: string[];
+    contextFilter?: ContextFilterFn;
+
+    /**
+     * connect context module to paren context module.
+     *
+     * _default: `true`_
+     */
+    connectParentContext?: boolean;
+
+    /** set initial context from parent, will await resolve */
+    skipInitialContext?: boolean;
+
+    /**
+     * Method for generating context query parameters.
+     */
+    contextParameterFn?: (args: {
+        search: string;
+        type: ContextModuleConfig['contextType'];
+    }) => string | QueryContextParameters;
+
+    resolveContext?: (
+        this: IContextProvider,
+        item: ContextItem | null,
+    ) => ReturnType<IContextProvider['resolveContext']>;
+
+    validateContext?: (
+        this: IContextProvider,
+        item: ContextItem | null,
+    ) => ReturnType<IContextProvider['validateContext']>;
+
+    resolveInitialContext?: (args: {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        ref?: AnyModuleInstance | any;
+        modules: ModuleInstance;
+    }) => ObservableInput<ContextItem | void>;
+}
+
+export interface IContextModuleConfigurator {
+    addConfigBuilder: (init: ContextConfigBuilderCallback) => void;
+}
+
+export class ContextModuleConfigurator implements IContextModuleConfigurator {
+    defaultExpireTime = 1 * 60 * 1000;
+
+    #configBuilders: Array<ContextConfigBuilderCallback> = [];
+
+    addConfigBuilder(init: ContextConfigBuilderCallback): void {
+        this.#configBuilders.push(init);
+    }
+
+    protected async _getServiceProvider(
+        init: ModuleInitializerArgs<IContextModuleConfigurator, [ServicesModule]>,
+    ): Promise<IApiProvider> {
+        if (init.hasModule('services')) {
+            return init.requireInstance('services');
+        } else {
+            const parentServiceModule = (init.ref as ModulesInstanceType<[ServicesModule]>)
+                ?.services;
+            if (parentServiceModule) {
+                return parentServiceModule;
+            }
+            throw Error('no service services provider configures [ServicesModule]');
+        }
+    }
+
+    public async createConfig(
+        init: ModuleInitializerArgs<IContextModuleConfigurator, [ServicesModule, NavigationModule]>,
+    ): Promise<ContextModuleConfig> {
+        const config = await this.#configBuilders.reduce(
+            async (cur, cb) => {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const builder = new ContextConfigBuilder<any, any>(init, await cur);
+                await Promise.resolve(cb(builder));
+                return Object.assign(cur, builder.config);
+            },
+            Promise.resolve({} as Partial<ContextModuleConfig>),
+        );
+
+        config.resolveInitialContext ??= resolveInitialContext();
+
+        // TODO - make less lazy
+        config.client ??= await (async (): Promise<ContextModuleConfig['client']> => {
+            const apiProvider = await this._getServiceProvider(init);
+            const contextClient = await apiProvider.createContextClient('json$');
+            return {
+                get: {
+                    client: {
+                        fn: (args) =>
+                            contextClient.get('v1', args, { selector: getContextSelector }),
+                    },
+                    key: ({ id }) => id,
+                    expire: this.defaultExpireTime,
+                },
+                query: {
+                    client: {
+                        fn: (query) =>
+                            contextClient.query(
+                                'v1',
+                                { query },
+                                { selector: queryContextSelector },
+                            ),
+                    },
+                    // TODO - might cast to checksum
+                    key: (args) => JSON.stringify(args),
+                    expire: this.defaultExpireTime,
+                },
+                related: {
+                    client: {
+                        fn: (args) => {
+                            return contextClient.related(
+                                'v1',
+                                { id: args.item.id, query: { filter: args.filter } },
+                                { selector: relatedContextSelector },
+                            );
+                        },
+                    },
+                    // TODO - might cast to checksum
+                    key: (args) => JSON.stringify(args),
+                    expire: this.defaultExpireTime,
+                },
+            };
+        })();
+
+        return config as ContextModuleConfig;
+    }
+}
+
+export default ContextModuleConfigurator;

package/src/errors.ts

@@ -0,0 +1,19 @@
+export class FusionContextSearchError extends Error {
+    #details;
+
+    get title(): string {
+        return this.#details.title;
+    }
+
+    constructor(
+        details: {
+            title: string;
+            description?: string;
+        },
+        options?: ErrorOptions,
+    ) {
+        super(details.description ?? details.title, options);
+        this.#details = details;
+        this.name = 'FusionContextSearchError';
+    }
+}

package/src/index.ts

@@ -0,0 +1,18 @@
+export {
+    ContextModuleConfigurator,
+    IContextModuleConfigurator,
+    ContextModuleConfig,
+} from './configurator';
+
+export { IContextProvider, ContextProvider } from './ContextProvider';
+
+export {
+    default,
+    ContextModule,
+    module as contextModule,
+    moduleKey as contextModuleKey,
+} from './module';
+
+export { enableContext } from './utils/enable-context';
+
+export * from './types';

package/src/module.ts

@@ -0,0 +1,91 @@
+import { catchError, EMPTY, from, Observable, switchMap, filter, Subscription } from 'rxjs';
+
+import { Module, ModulesInstance } from '@equinor/fusion-framework-module';
+
+import { EventModule } from '@equinor/fusion-framework-module-event';
+import { ServicesModule } from '@equinor/fusion-framework-module-services';
+import { NavigationModule } from '@equinor/fusion-framework-module-navigation';
+
+import { IContextModuleConfigurator, ContextModuleConfigurator } from './configurator';
+import { IContextProvider, ContextProvider } from './ContextProvider';
+import { ContextItem } from './types';
+
+export type ContextModuleKey = 'context';
+
+export const moduleKey: ContextModuleKey = 'context';
+
+export type ContextModule = Module<
+    ContextModuleKey,
+    IContextProvider,
+    IContextModuleConfigurator,
+    [ServicesModule, EventModule, NavigationModule]
+>;
+
+export const module: ContextModule = {
+    name: moduleKey,
+    configure: () => new ContextModuleConfigurator(),
+    initialize: async function (args) {
+        const config = await (args.config as ContextModuleConfigurator).createConfig(args);
+        const event = args.hasModule('event') ? await args.requireInstance('event') : undefined;
+        const parentProvider = (args.ref as ModulesInstance<[ContextModule]>)?.context;
+        const provider = new ContextProvider({ config, event, parentContext: parentProvider });
+
+        const subscription = new Subscription(() => provider.dispose());
+
+        this.postInitialize = (args) =>
+            new Observable((subscriber) => {
+                const resolveInitialContext$ = config.resolveInitialContext
+                    ? from(config.resolveInitialContext(args)).pipe(
+                          filter((item): item is ContextItem => !!item),
+                          switchMap((item) =>
+                              args.modules.context.setCurrentContext(item, {
+                                  validate: true,
+                                  resolve: true,
+                              }),
+                          ),
+                      )
+                    : EMPTY;
+
+                subscriber.add(
+                    resolveInitialContext$
+                        .pipe(
+                            catchError((err) => {
+                                console.warn(
+                                    'ContextModule.postInitialize',
+                                    'failed to resolve initial context',
+                                    err,
+                                );
+                                return EMPTY;
+                            }),
+                        )
+                        .subscribe({
+                            next: (item) => {
+                                console.debug(
+                                    'ContextModule.postInitialize',
+                                    `initial context was resolved to [${item ? item.id : 'none'}]`,
+                                    item,
+                                );
+                            },
+                            complete: () => {
+                                if (config.connectParentContext !== false && parentProvider) {
+                                    provider.connectParentContext(parentProvider);
+                                }
+                                subscriber.complete();
+                            },
+                        }),
+                );
+            });
+
+        this.dispose = () => subscription.unsubscribe();
+
+        return provider;
+    },
+};
+
+declare module '@equinor/fusion-framework-module' {
+    interface Modules {
+        context: ContextModule;
+    }
+}
+
+export default module;

package/src/selectors.ts

@@ -0,0 +1,41 @@
+import { ApiVersion, ApiContextEntity } from '@equinor/fusion-framework-module-services/context';
+import type { GetContextResponse } from '@equinor/fusion-framework-module-services/context/get';
+import type { QueryContextResponse } from '@equinor/fusion-framework-module-services/context/query';
+import type { RelatedContextResponse } from '@equinor/fusion-framework-module-services/context/related';
+import type { ContextItem, ContextItemType } from './types';
+
+const parseContextType = (type: GetContextResponse<'v1'>['type']): ContextItemType => ({
+    id: type.id,
+    isChildType: type.isChildType,
+    parentTypeIds: type.parentTypeIds ?? [],
+});
+
+const parseContextItem = (item: ApiContextEntity<ApiVersion.v1>): ContextItem => {
+    return {
+        id: item.id,
+        externalId: item.externalId ?? undefined,
+        isActive: item.isActive,
+        isDeleted: item.isDeleted,
+        created: new Date(item.created),
+        source: item.source ?? undefined,
+        title: item.title ?? undefined,
+        type: parseContextType(item.type),
+        // TODO
+        value: item.value ?? {},
+    };
+};
+
+export const getContextSelector = async (response: Response): Promise<ContextItem> => {
+    const result = (await response.json()) as GetContextResponse<'v1'>;
+    return parseContextItem(result);
+};
+
+export const queryContextSelector = async (response: Response): Promise<ContextItem[]> => {
+    const result = (await response.json()) as QueryContextResponse<'v1'>;
+    return result.map(parseContextItem);
+};
+
+export const relatedContextSelector = async (response: Response): Promise<ContextItem[]> => {
+    const result = (await response.json()) as RelatedContextResponse<'v1'>;
+    return result.map(parseContextItem);
+};

package/src/types.ts

@@ -0,0 +1,33 @@
+export type ContextItem<TType extends Record<string, unknown> = Record<string, unknown>> = {
+    id: string;
+    externalId?: string;
+    source?: string;
+    type: ContextItemType;
+    value: TType;
+    title?: string;
+    subTitle?: string;
+    isActive?: boolean;
+    isDeleted?: boolean;
+    created?: Date;
+    updated?: Date;
+    graphic?: string;
+    meta?: string;
+};
+
+export interface ContextItemType {
+    id: string;
+    isChildType?: boolean;
+    parentTypeIds?: string[];
+}
+
+export type QueryContextParameters = {
+    search?: string;
+    filter?: {
+        type?: string[];
+        externalId?: string;
+    };
+};
+
+export type RelatedContextParameters = { item: ContextItem; filter?: { type?: string[] } };
+
+export type ContextFilterFn = (items: ContextItem[]) => ContextItem[];

package/src/utils/enable-context.ts

@@ -0,0 +1,31 @@
+import type {
+    IModulesConfigurator,
+    AnyModule,
+    ModuleInitializerArgs,
+} from '@equinor/fusion-framework-module';
+import type { IContextModuleConfigurator } from '../configurator';
+import type { ContextConfigBuilder } from '../ContextConfigBuilder';
+
+import { module } from '../module';
+
+/**
+ * Method for enabling the Service module
+ * @param configurator - configuration object
+ */
+export const enableContext = (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    configurator: IModulesConfigurator<any, any>,
+    builder?: <TDeps extends Array<AnyModule> = []>(
+        builder: ContextConfigBuilder<
+            TDeps,
+            ModuleInitializerArgs<IContextModuleConfigurator, TDeps>
+        >,
+    ) => void | Promise<void>,
+): void => {
+    configurator.addConfig({
+        module,
+        configure: (contextConfigurator) => {
+            builder && contextConfigurator.addConfigBuilder(builder);
+        },
+    });
+};

package/src/utils/index.ts

@@ -0,0 +1,2 @@
+export { enableContext } from './enable-context';
+export { resolveInitialContext } from './resolve-initial-context';

package/src/utils/resolve-context-from-path.ts

@@ -0,0 +1,34 @@
+import { EMPTY } from 'rxjs';
+
+import { ModuleType } from '@equinor/fusion-framework-module';
+
+import { type ContextModule } from '../module';
+
+export type ContextPathResolveArgs = {
+    extract?: (path: string) => string | undefined;
+    validate?: (contextId: string) => boolean;
+};
+
+const matchGUID =
+    /^(?:(?:[0-9a-fA-F]){8}-(?:[0-9a-fA-F]){4}-(?:[0-9a-fA-F]){4}-(?:[0-9a-fA-F]){4}-(?:[0-9a-fA-F]){12})$/;
+
+const extractContextIdFromPath = (path: string): string | undefined =>
+    path.replace(/^\/+/, '').split('/').shift();
+
+const validateContextId = (contextId: string): boolean => !!contextId.match(matchGUID);
+
+export const resolveContextFromPath =
+    (context: ModuleType<ContextModule>, args?: ContextPathResolveArgs) => (path: string) => {
+        const { extract = extractContextIdFromPath, validate = validateContextId } = args ?? {};
+        const contextId = extract(path);
+        if (!contextId) {
+            return EMPTY;
+        }
+        if (validate(contextId)) {
+            return context.contextClient.resolveContext(contextId);
+        }
+
+        throw Error(`Failed to validate context [${contextId}] from path [${path}]`);
+    };
+
+export default resolveContextFromPath;

package/src/utils/resolve-initial-context.ts

@@ -0,0 +1,29 @@
+import { ModulesInstance } from '@equinor/fusion-framework-module';
+import { ContextModule } from '../module';
+import { type ContextModuleConfig } from '../configurator';
+import { concat, EMPTY, first, of } from 'rxjs';
+
+import { ContextPathResolveArgs, resolveContextFromPath } from './resolve-context-from-path';
+
+export const resolveContextFromParent: ContextModuleConfig['resolveInitialContext'] = ({ ref }) => {
+    const parentContext = (ref as ModulesInstance<[ContextModule]>)?.context;
+    if (!parentContext) {
+        throw Error(['resolveContextFromNavigation', 'ref does not support context!'].join('\n'));
+    }
+    return parentContext.currentContext ? of(parentContext.currentContext) : EMPTY;
+};
+
+export const resolveInitialContext =
+    (options?: {
+        path?: ContextPathResolveArgs;
+    }): Required<ContextModuleConfig>['resolveInitialContext'] =>
+    ({ ref, modules }) => {
+        const { context, navigation } = modules;
+        const pathResolver = resolveContextFromPath(context, options?.path);
+        return concat(
+            navigation ? pathResolver(navigation.path.pathname) : EMPTY,
+            resolveContextFromParent({ ref, modules }),
+        ).pipe(first());
+    };
+
+export default resolveInitialContext;

package/src/version.ts

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

package/tsconfig.json

@@ -0,0 +1,33 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist/esm",
+    "rootDir": "src",
+    "declarationDir": "./dist/types",
+    
+  },
+  "references": [
+    {
+      "path": "../../utils/query"
+    },
+    {
+      "path": "../module"
+    },
+    {
+      "path": "../navigation"
+    },
+    {
+      "path": "../event"
+    },
+    {
+      "path": "../services"
+    },
+  ],
+  "include": [
+    "src/**/*",
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}