@equinor/fusion-framework-module-context 0.6.11 → 1.0.0

package/dist/types/ContextConfigBuilder.d.ts

@@ -0,0 +1,19 @@
+import type { AnyModule, ModuleInitializerArgs, Modules, ModuleType } from '@equinor/fusion-framework-module';
+import type { QueryCtorOptions, QueryFn } from '@equinor/fusion-query';
+import type { GetContextParameters } from './client/ContextClient';
+import type { ContextModuleConfig, ContextModuleConfigurator, IContextModuleConfigurator } from './configurator';
+import type { ContextItem, QueryContextParameters } from './types';
+export type ContextConfigBuilderCallback = <TDeps extends Array<AnyModule> = []>(builder: ContextConfigBuilder<TDeps, ModuleInitializerArgs<IContextModuleConfigurator, TDeps>>) => void | Promise<void>;
+export declare class ContextConfigBuilder<TModules extends Array<AnyModule> = [], TInit extends ModuleInitializerArgs<any, any> = ModuleInitializerArgs<ContextModuleConfigurator, TModules>> {
+    #private;
+    config: Partial<ContextModuleConfig>;
+    constructor(init: TInit, config?: Partial<ContextModuleConfig>);
+    requireInstance<TKey extends string = Extract<keyof Modules, string>>(module: TKey): Promise<ModuleType<Modules[TKey]>>;
+    requireInstance<T>(module: string): Promise<T>;
+    setContextType(type: ContextModuleConfig['contextType']): void;
+    setContextFilter(filter: ContextModuleConfig['contextFilter']): void;
+    setContextClient(client: {
+        get: QueryFn<ContextItem, GetContextParameters> | QueryCtorOptions<ContextItem, GetContextParameters>;
+        query: QueryFn<ContextItem[], QueryContextParameters> | QueryCtorOptions<ContextItem[], QueryContextParameters>;
+    }, expire?: number): void;
+}

package/dist/types/client/ContextClient.d.ts

@@ -1,11 +1,8 @@
 import { Observable } from 'rxjs';
 import { Query, QueryCtorOptions } from '@equinor/fusion-query';
 import { ContextItem } from '../types';
-export type ContextClientOptions = {
-    query: QueryCtorOptions<ContextItem, {
-        id: string;
-    }>;
-    initial?: ContextItem;
+export type GetContextParameters = {
+    id: string;
 };
 export declare class ContextClient extends Observable<ContextItem> {
     #private;
@@ -14,7 +11,7 @@ export declare class ContextClient extends Observable<ContextItem> {
     get client(): Query<ContextItem, {
         id: string;
     }>;
-    constructor(options: ContextClientOptions);
+    constructor(options: QueryCtorOptions<ContextItem, GetContextParameters>);
     setCurrentContext(idOrItem?: string | ContextItem): void;
     resolveContext(id: string): Observable<ContextItem>;
 }

package/dist/types/configurator.d.ts

@@ -1,27 +1,25 @@
-import { AnyModule, ModuleInitializerArgs } from '@equinor/fusion-framework-module';
+import { ModuleInitializerArgs } from '@equinor/fusion-framework-module';
 import { ServicesModule, IApiProvider } from '@equinor/fusion-framework-module-services';
-import type { QueryCtorOptions } from '@equinor/fusion-query';
-import { ContextClientOptions } from './client/ContextClient';
-import { ContextItem, QueryContextParameters } from './types';
-export interface IContextModuleConfig {
-    getContext: ContextClientOptions;
-    queryContext: QueryCtorOptions<ContextItem[], QueryContextParameters>;
+import { QueryCtorOptions } from '@equinor/fusion-query';
+import { ContextFilterFn, ContextItem, QueryContextParameters } from './types';
+import { GetContextParameters } from './client/ContextClient';
+import { ContextConfigBuilderCallback } from './ContextConfigBuilder';
+export interface ContextModuleConfig {
+    client: {
+        get: QueryCtorOptions<ContextItem, GetContextParameters>;
+        query: QueryCtorOptions<ContextItem[], QueryContextParameters>;
+    };
     contextType?: string[];
-    contextFilter?: (items: Array<ContextItem>) => Array<ContextItem>;
+    contextFilter?: ContextFilterFn;
 }
-export interface IContextModuleConfigurator<TDeps extends Array<AnyModule> = [ServicesModule]> {
-    createConfig: (args: ModuleInitializerArgs<IContextModuleConfigurator, TDeps>) => Promise<IContextModuleConfig>;
-    processConfig: (config: IContextModuleConfig) => IContextModuleConfig;
+export interface IContextModuleConfigurator {
+    addConfigBuilder: (init: ContextConfigBuilderCallback) => void;
 }
-export declare class ContextModuleConfigurator implements IContextModuleConfigurator<[ServicesModule]> {
-    getContext?: Promise<ContextClientOptions['query']['client']>;
+export declare class ContextModuleConfigurator implements IContextModuleConfigurator {
+    #private;
     defaultExpireTime: number;
-    protected _createContextClientGet(apiProvider: IApiProvider): Promise<QueryCtorOptions<ContextItem, {
-        id: string;
-    }>['client']>;
-    protected _createContextClientQuery(apiProvider: IApiProvider): Promise<QueryCtorOptions<ContextItem[], QueryContextParameters>['client']>;
+    addConfigBuilder(init: ContextConfigBuilderCallback): void;
     protected _getServiceProvider(init: ModuleInitializerArgs<IContextModuleConfigurator, [ServicesModule]>): Promise<IApiProvider>;
-    createConfig(init: ModuleInitializerArgs<IContextModuleConfigurator, [ServicesModule]>): Promise<IContextModuleConfig>;
-    processConfig(config: IContextModuleConfig): IContextModuleConfig;
+    createConfig(init: ModuleInitializerArgs<IContextModuleConfigurator, [ServicesModule]>): Promise<ContextModuleConfig>;
 }
 export default ContextModuleConfigurator;

package/dist/types/enable-context.d.ts

@@ -0,0 +1,4 @@
+import type { IModulesConfigurator, AnyModule, ModuleInitializerArgs } from '@equinor/fusion-framework-module';
+import type { IContextModuleConfigurator } from 'configurator';
+import type { ContextConfigBuilder } from 'ContextConfigBuilder';
+export declare const enableContext: (configurator: IModulesConfigurator, builder?: (<TDeps extends AnyModule[] = []>(builder: ContextConfigBuilder<TDeps, ModuleInitializerArgs<IContextModuleConfigurator, TDeps>>) => void | Promise<void>) | undefined) => void;

package/dist/types/index.d.ts

@@ -1,7 +1,5 @@
-import { IModulesConfigurator } from '@equinor/fusion-framework-module';
-import { IContextModuleConfig } from './configurator';
-export declare const enableContext: (configurator: IModulesConfigurator, options?: Pick<IContextModuleConfig, 'contextFilter' | 'contextType'>) => void;
-export { ContextModuleConfigurator, IContextModuleConfigurator, IContextModuleConfig, } from './configurator';
+export { ContextModuleConfigurator, IContextModuleConfigurator, ContextModuleConfig, } from './configurator';
 export { IContextProvider, ContextProvider } from './provider';
 export { default, ContextModule, module as contextModule, moduleKey as contextModuleKey, } from './module';
+export { enableContext } from './enable-context';
 export * from './types';

package/dist/types/module.d.ts

@@ -10,4 +10,9 @@ export type ContextModule = Module<ContextModuleKey, IContextProvider, IContextM
     EventModule
 ]>;
 export declare const module: ContextModule;
+declare module '@equinor/fusion-framework-module' {
+    interface Modules {
+        context: ContextModule;
+    }
+}
 export default module;

package/dist/types/provider.d.ts

@@ -1,5 +1,5 @@
 import { Observable } from 'rxjs';
-import { IContextModuleConfig } from './configurator';
+import { ContextModuleConfig } from './configurator';
 import { ContextClient } from './client/ContextClient';
 import { ContextItem, QueryContextParameters } from './types';
 import { ModuleType } from '@equinor/fusion-framework-module';
@@ -10,6 +10,7 @@ export interface IContextProvider {
     readonly queryClient: Query<ContextItem[], QueryContextParameters>;
     readonly currentContext$: Observable<ContextItem | undefined>;
     currentContext: ContextItem | undefined;
+    queryContext(search: string): Observable<Array<ContextItem>>;
 }
 export declare class ContextProvider implements IContextProvider {
     #private;
@@ -21,7 +22,7 @@ export declare class ContextProvider implements IContextProvider {
     get currentContext(): ContextItem | undefined;
     set currentContext(context: ContextItem | undefined);
     constructor(args: {
-        config: IContextModuleConfig;
+        config: ContextModuleConfig;
         event?: ModuleType<EventModule>;
         parentContext?: IContextProvider;
     });

package/dist/types/types.d.ts

@@ -22,3 +22,4 @@ export type QueryContextParameters = {
         externalId?: string;
     };
 };
+export type ContextFilterFn = (items: ContextItem[]) => ContextItem[];

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@equinor/fusion-framework-module-context",
-    "version": "0.6.11",
+    "version": "1.0.0",
     "description": "",
     "main": "./dist/esm/index.js",
     "exports": {
@@ -31,17 +31,17 @@
         "directory": "packages/modules-context"
     },
     "dependencies": {
-        "@equinor/fusion-query": "^0.3.1"
+        "@equinor/fusion-query": "^1.0.0"
     },
     "devDependencies": {
         "@equinor/fusion-framework-module": "^1.2.10",
         "@equinor/fusion-framework-module-event": "^1.1.6",
-        "@equinor/fusion-framework-module-services": "^0.5.21",
+        "@equinor/fusion-framework-module-services": "^1.0.0",
         "rxjs": "^7.5.7"
     },
     "peerDependencies": {
         "@equinor/fusion-framework-module": "^1.2.5",
         "rxjs": "^7.5.7"
     },
-    "gitHead": "909e48f515aa842e15eaeb26a7f75c160da39e84"
+    "gitHead": "b93e25b79c3b34ee46bd3a16b059e850acdffe95"
 }

package/src/ContextConfigBuilder.ts

@@ -0,0 +1,89 @@
+import type {
+    AnyModule,
+    ModuleInitializerArgs,
+    Modules,
+    ModuleType,
+} from '@equinor/fusion-framework-module';
+
+import type { QueryCtorOptions, QueryFn } from '@equinor/fusion-query';
+
+import type { GetContextParameters } from './client/ContextClient';
+
+import type {
+    ContextModuleConfig,
+    ContextModuleConfigurator,
+    IContextModuleConfigurator,
+} from './configurator';
+
+import type { ContextItem, QueryContextParameters } from './types';
+
+export type ContextConfigBuilderCallback = <TDeps extends Array<AnyModule> = []>(
+    builder: ContextConfigBuilder<TDeps, ModuleInitializerArgs<IContextModuleConfigurator, TDeps>>
+) => void | Promise<void>;
+
+export class ContextConfigBuilder<
+    TModules extends Array<AnyModule> = [],
+    TInit extends ModuleInitializerArgs<any, any> = ModuleInitializerArgs<
+        ContextModuleConfigurator,
+        TModules
+    >
+> {
+    #init: TInit;
+    constructor(init: TInit, public config: Partial<ContextModuleConfig> = {}) {
+        this.#init = init;
+    }
+
+    requireInstance<TKey extends string = Extract<keyof Modules, string>>(
+        module: TKey
+    ): Promise<ModuleType<Modules[TKey]>>;
+
+    requireInstance<T>(module: string): Promise<T>;
+
+    requireInstance(module: string): Promise<any> {
+        return this.#init.requireInstance(module);
+    }
+
+    setContextType(type: ContextModuleConfig['contextType']) {
+        this.config.contextType = type;
+    }
+
+    setContextFilter(filter: ContextModuleConfig['contextFilter']) {
+        this.config.contextFilter = filter;
+    }
+
+    setContextClient(
+        client: {
+            get:
+                | QueryFn<ContextItem, GetContextParameters>
+                | QueryCtorOptions<ContextItem, GetContextParameters>;
+            query:
+                | QueryFn<ContextItem[], QueryContextParameters>
+                | QueryCtorOptions<ContextItem[], QueryContextParameters>;
+        },
+        expire = 1 * 60 * 1000
+    ): void {
+        this.config.client = {
+            get:
+                typeof client.get === 'function'
+                    ? {
+                          key: ({ id }) => id,
+                          client: {
+                              fn: client.get,
+                          },
+                          expire,
+                      }
+                    : client.get,
+            query:
+                typeof client.query === 'function'
+                    ? {
+                          // TODO - might cast to checksum
+                          key: (args) => JSON.stringify(args),
+                          client: {
+                              fn: client.query,
+                          },
+                          expire,
+                      }
+                    : client.query,
+        };
+    }
+}

package/src/client/ContextClient.ts

@@ -5,10 +5,7 @@ import { Query, QueryCtorOptions } from '@equinor/fusion-query';
 
 import { ContextItem } from '../types';
 
-export type ContextClientOptions = {
-    query: QueryCtorOptions<ContextItem, { id: string }>;
-    initial?: ContextItem;
-};
+export type GetContextParameters = { id: string };
 
 export class ContextClient extends Observable<ContextItem> {
     #client: Query<ContextItem, { id: string }>;
@@ -27,10 +24,10 @@ export class ContextClient extends Observable<ContextItem> {
         return this.#client;
     }
 
-    constructor(options: ContextClientOptions) {
+    constructor(options: QueryCtorOptions<ContextItem, GetContextParameters>) {
         super((observer) => this.#currentContext$.subscribe(observer));
-        this.#client = new Query(options.query);
-        this.#currentContext$ = new BehaviorSubject<ContextItem | undefined>(options.initial);
+        this.#client = new Query(options);
+        this.#currentContext$ = new BehaviorSubject<ContextItem | undefined>(undefined);
     }
 
     public setCurrentContext(idOrItem?: string | ContextItem) {

package/src/configurator.ts

@@ -1,56 +1,31 @@
-import {
-    AnyModule,
-    ModuleInitializerArgs,
-    ModulesInstanceType,
-} from '@equinor/fusion-framework-module';
+import { ModuleInitializerArgs, ModulesInstanceType } from '@equinor/fusion-framework-module';
 import { ServicesModule, IApiProvider } from '@equinor/fusion-framework-module-services';
-import type { QueryCtorOptions } from '@equinor/fusion-query';
-import { ContextClientOptions } from './client/ContextClient';
-import { ContextItem, QueryContextParameters } from './types';
 import { getContextSelector, queryContextSelector } from './selectors';
+import { QueryCtorOptions } from '@equinor/fusion-query';
+import { ContextFilterFn, ContextItem, QueryContextParameters } from './types';
+import { GetContextParameters } from './client/ContextClient';
+import { ContextConfigBuilder, ContextConfigBuilderCallback } from './ContextConfigBuilder';
 
-export interface IContextModuleConfig {
-    getContext: ContextClientOptions;
-    queryContext: QueryCtorOptions<ContextItem[], QueryContextParameters>;
+export interface ContextModuleConfig {
+    client: {
+        get: QueryCtorOptions<ContextItem, GetContextParameters>;
+        query: QueryCtorOptions<ContextItem[], QueryContextParameters>;
+    };
     contextType?: string[];
-    contextFilter?: (items: Array<ContextItem>) => Array<ContextItem>;
+    contextFilter?: ContextFilterFn;
 }
 
-export interface IContextModuleConfigurator<TDeps extends Array<AnyModule> = [ServicesModule]> {
-    /** fired on initialize of module */
-    createConfig: (
-        args: ModuleInitializerArgs<IContextModuleConfigurator, TDeps>
-    ) => Promise<IContextModuleConfig>;
-
-    /** post process function for altering created config  */
-    processConfig: (config: IContextModuleConfig) => IContextModuleConfig;
+export interface IContextModuleConfigurator {
+    addConfigBuilder: (init: ContextConfigBuilderCallback) => void;
 }
 
-export class ContextModuleConfigurator implements IContextModuleConfigurator<[ServicesModule]> {
-    getContext?: Promise<ContextClientOptions['query']['client']>;
-
+export class ContextModuleConfigurator implements IContextModuleConfigurator {
     defaultExpireTime = 1 * 60 * 1000;
 
-    protected async _createContextClientGet(
-        apiProvider: IApiProvider
-    ): Promise<QueryCtorOptions<ContextItem, { id: string }>['client']> {
-        const contextClient = await apiProvider.createContextClient('json$');
-        return {
-            fn: (args) => {
-                return contextClient.get('v1', args, { selector: getContextSelector });
-            },
-        };
-    }
+    #configBuilders: Array<ContextConfigBuilderCallback> = [];
 
-    protected async _createContextClientQuery(
-        apiProvider: IApiProvider
-    ): Promise<QueryCtorOptions<ContextItem[], QueryContextParameters>['client']> {
-        const contextClient = await apiProvider.createContextClient('json$');
-        return {
-            fn: (query) => {
-                return contextClient.query('v1', { query }, { selector: queryContextSelector });
-            },
-        };
+    addConfigBuilder(init: ContextConfigBuilderCallback): void {
+        this.#configBuilders.push(init);
     }
 
     protected async _getServiceProvider(
@@ -70,28 +45,43 @@ export class ContextModuleConfigurator implements IContextModuleConfigurator<[Se
 
     public async createConfig(
         init: ModuleInitializerArgs<IContextModuleConfigurator, [ServicesModule]>
-    ) {
-        const apiProvider = await this._getServiceProvider(init);
-        const config: IContextModuleConfig = {
-            getContext: {
-                query: {
-                    client: await this._createContextClientGet(apiProvider),
+    ): Promise<ContextModuleConfig>  {
+        const config = await this.#configBuilders.reduce(async (cur, cb) => {
+            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>));
+
+        // 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,
                 },
-            },
-            queryContext: {
-                client: await this._createContextClientQuery(apiProvider),
-                key: (args) => JSON.stringify(args),
-                expire: this.defaultExpireTime,
-            },
-        };
-
-        return this.processConfig(config);
-    }
+                query: {
+                    client: {
+                        fn: (query) =>
+                            contextClient.query(
+                                'v1',
+                                { query },
+                                { selector: queryContextSelector }
+                            ),
+                    },
+                    // TODO - might cast to checksum
+                    key: (args) => JSON.stringify(args),
+                    expire: this.defaultExpireTime,
+                },
+            };
+        })();
 
-    public processConfig(config: IContextModuleConfig): IContextModuleConfig {
-        return config;
+        return config as ContextModuleConfig;
     }
 }
 

package/src/enable-context.ts

@@ -0,0 +1,30 @@
+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 = (
+    configurator: IModulesConfigurator,
+    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/index.ts

@@ -1,32 +1,7 @@
-import { IModulesConfigurator } from '@equinor/fusion-framework-module';
-import { IContextModuleConfig } from './configurator';
-
-import { module } from './module';
-/**
- * Method for enabling the Service module
- * @param configurator - configuration object
- */
-export const enableContext = (
-    configurator: IModulesConfigurator,
-    options?: Pick<IContextModuleConfig, 'contextFilter' | 'contextType'>
-): void => {
-    configurator.addConfig({
-        module,
-        configure: (contextConfigurator) => {
-            contextConfigurator.processConfig = (config) => {
-                return {
-                    ...config,
-                    ...options,
-                };
-            };
-        },
-    });
-};
-
 export {
     ContextModuleConfigurator,
     IContextModuleConfigurator,
-    IContextModuleConfig,
+    ContextModuleConfig,
 } from './configurator';
 
 export { IContextProvider, ContextProvider } from './provider';
@@ -38,4 +13,6 @@ export {
     moduleKey as contextModuleKey,
 } from './module';
 
+export { enableContext } from './enable-context';
+
 export * from './types';

package/src/module.ts

@@ -21,7 +21,7 @@ export const module: ContextModule = {
     name: moduleKey,
     configure: () => new ContextModuleConfigurator(),
     initialize: async (args) => {
-        const config = await args.config.createConfig(args);
+        const config = await (args.config as ContextModuleConfigurator).createConfig(args);
         const event = args.hasModule('event') ? await args.requireInstance('event') : undefined;
         const parentContext = (args.ref as ModulesInstance<[ContextModule]>)?.context;
         return new ContextProvider({ config, event, parentContext });
@@ -32,4 +32,10 @@ export const module: ContextModule = {
     },
 };
 
+declare module '@equinor/fusion-framework-module' {
+    interface Modules {
+        context: ContextModule;
+    }
+}
+
 export default module;

package/src/provider.ts

@@ -1,7 +1,7 @@
 import { lastValueFrom, Observable, Subscription } from 'rxjs';
 import { map, pairwise } from 'rxjs/operators';
 
-import { IContextModuleConfig } from './configurator';
+import { ContextModuleConfig } from './configurator';
 
 import { ContextClient } from './client/ContextClient';
 import { ContextItem, QueryContextParameters } from './types';
@@ -25,6 +25,8 @@ export interface IContextProvider {
 
     readonly currentContext$: Observable<ContextItem | undefined>;
     currentContext: ContextItem | undefined;
+
+    queryContext(search: string): Observable<Array<ContextItem>>;
 }
 
 export class ContextProvider implements IContextProvider {
@@ -35,8 +37,8 @@ export class ContextProvider implements IContextProvider {
 
     #subscriptions = new Subscription();
 
-    #contextType?: IContextModuleConfig['contextType'];
-    #contextFilter: IContextModuleConfig['contextFilter'];
+    #contextType?: ContextModuleConfig['contextType'];
+    #contextFilter: ContextModuleConfig['contextFilter'];
 
     public get contextClient() {
         return this.#contextClient;
@@ -93,7 +95,7 @@ export class ContextProvider implements IContextProvider {
     }
 
     constructor(args: {
-        config: IContextModuleConfig;
+        config: ContextModuleConfig;
         event?: ModuleType<EventModule>;
         parentContext?: IContextProvider;
     }) {
@@ -102,9 +104,8 @@ export class ContextProvider implements IContextProvider {
         this.#contextType = config.contextType;
         this.#contextFilter = config.contextFilter;
 
-        this.#contextClient = new ContextClient(config.getContext);
-
-        this.#contextQuery = new Query(config.queryContext);
+        this.#contextClient = new ContextClient(config.client.get);
+        this.#contextQuery = new Query(config.client.query);
 
         if (event) {
             this.#event = event;

package/src/types.ts

@@ -24,3 +24,5 @@ export type QueryContextParameters = {
         externalId?: string;
     };
 };
+
+export type ContextFilterFn = (items: ContextItem[]) => ContextItem[];