@komaci/prefetch 242.2.4 → 244.0.0

package/build/__tests__/prefetchService.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=prefetchService.spec.d.ts.map

package/build/__tests__/prefetchService.spec.js

@@ -0,0 +1,865 @@
+import waitForExpect from 'wait-for-expect';
+import { getPrefetchService } from '../modules/komaci/prefetch/prefetch';
+import { setupRouterMock, createPageRef, setupPrefetch, defaultRoutingResult, mockPrefetchConfig, mockPrefetchConfigStatusError, mockPrefetchConfigStateError, createAdgModule, } from './utils';
+jest.mock('lwr/router');
+import * as ResolverApi from 'komaci/resolver';
+import { getInstrumentation } from 'o11y/client';
+const mockInstrumentation = getInstrumentation('komaci');
+beforeEach(() => {
+    jest.clearAllMocks();
+});
+afterEach(() => {
+    expect.hasAssertions();
+});
+jest.setTimeout(500);
+function invokeCallbackWithState(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+callback, state, errors = [], index = 0) {
+    callback === null || callback === void 0 ? void 0 : callback({
+        index,
+        status: {
+            getState: function () {
+                return state;
+            },
+            getErrorMessages: function () {
+                return errors;
+            },
+        },
+    });
+}
+describe('prefetchService', () => {
+    describe('calling prefetch', () => {
+        it('throws if no router is given', () => {
+            expect(() => {
+                getPrefetchService(null, []);
+            }).toThrowError(/Must provide Router./);
+        });
+        it('constructs when given valid router', () => {
+            const { createRouter } = setupRouterMock();
+            const router = createRouter({});
+            const prefetchService = getPrefetchService(router, []);
+            expect(prefetchService).toBeDefined();
+        });
+    });
+    describe('prefetching an address', () => {
+        const pageRef = createPageRef();
+        it('calls onUpdateState with "running" upon init', async () => {
+            expect.assertions(3);
+            const { createRouter } = setupRouterMock();
+            const onStateChanged = mockPrefetchConfig.onStateChanged;
+            const setup = setupPrefetch(createRouter, [pageRef], mockPrefetchConfig);
+            const service = setup.run();
+            await waitForExpect(() => {
+                expect(onStateChanged).toHaveBeenCalledTimes(2);
+                expect(onStateChanged).toHaveBeenCalledWith(expect.objectContaining({ state: 'running' }));
+                expect(service.getState()).toBe('done');
+            });
+        });
+        it('calls bulkResolver with adgInput', async () => {
+            expect.assertions(3);
+            const routingResult = defaultRoutingResult(pageRef);
+            const { viewset = {} } = routingResult;
+            let adgModulesImporter;
+            if (viewset['default']) {
+                const viewInfo = viewset['default'];
+                const komaciSpecifier = '@salesforce/komaci/' + viewInfo.specifier.replace('/', '__');
+                adgModulesImporter = () => import(komaciSpecifier);
+            }
+            const adgFn = (await (adgModulesImporter === null || adgModulesImporter === void 0 ? void 0 : adgModulesImporter())).default;
+            const { createRouter } = setupRouterMock(() => routingResult);
+            const setup = setupPrefetch(createRouter, [pageRef], mockPrefetchConfig);
+            setup.run();
+            const mockGetBulkAdgResolver = jest.spyOn(ResolverApi, 'getBulkAdgResolver');
+            await waitForExpect(() => {
+                expect(mockGetBulkAdgResolver).toBeCalledTimes(1);
+                expect(mockGetBulkAdgResolver).toBeCalledWith(adgFn, expect.arrayContaining([
+                    expect.objectContaining({
+                        context: { CurrentPageReference: pageRef },
+                    }),
+                ]), expect.anything(), {
+                    downloadImageFunc: undefined,
+                    instrumentationCtx: {
+                        isRootActivitySampled: true,
+                        rootId: 'abcd-1234',
+                    },
+                    MaxResolutionDepth: 512,
+                    WireTimeout: 180 * 1000,
+                    WireSlowRunningTimeout: 30 * 1000,
+                });
+                expect(mockGetBulkAdgResolver.mock.calls[0][1]).toHaveLength(1);
+            });
+        });
+        it('calls onAddressProcessed & onStateChanged', async () => {
+            expect.assertions(7);
+            const { createRouter } = setupRouterMock();
+            const { onAddressProcessed, onStateChanged } = mockPrefetchConfig;
+            const setup = setupPrefetch(createRouter, [pageRef], mockPrefetchConfig);
+            const prefetchService = setup.run();
+            await waitForExpect(() => {
+                expect(onStateChanged).toBeCalledTimes(2);
+                expect(onStateChanged).toHaveBeenNthCalledWith(1, expect.objectContaining({ state: 'running' }));
+                expect(onAddressProcessed).toBeCalledTimes(1);
+                expect(onAddressProcessed).toHaveBeenCalledWith(expect.objectContaining({
+                    state: 'completed',
+                    address: pageRef,
+                }));
+                expect(onStateChanged).toHaveBeenNthCalledWith(2, expect.objectContaining({ state: 'done' }));
+                onStateChanged.mockClear();
+                prefetchService.stop();
+                expect(onStateChanged).toBeCalledTimes(1);
+                expect(onStateChanged).toBeCalledWith(expect.objectContaining({ state: 'stopped' }));
+            });
+        });
+        it('prefetchService.stop() updates onStateChanged to "stopped"', async () => {
+            expect.assertions(5);
+            const onStateChanged = mockPrefetchConfig.onStateChanged;
+            const { createRouter } = setupRouterMock();
+            const setup = setupPrefetch(createRouter, [pageRef], mockPrefetchConfig);
+            const service = setup.run();
+            await waitForExpect(() => {
+                expect(onStateChanged).toHaveBeenCalledTimes(2);
+                expect(onStateChanged).toHaveBeenNthCalledWith(1, expect.objectContaining({ state: 'running' }));
+                expect(onStateChanged).toHaveBeenNthCalledWith(2, expect.objectContaining({ state: 'done' }));
+                service.stop();
+                expect(onStateChanged).toHaveBeenNthCalledWith(3, expect.objectContaining({ state: 'stopped' }));
+                onStateChanged.mockClear();
+                service.stop();
+                expect(onStateChanged).toHaveBeenCalledTimes(0);
+            });
+        });
+        it('calls onStateChanged with "stopped", even if a batch has no resolvers', async () => {
+            expect.assertions(4);
+            const onStateChanged = mockPrefetchConfig.onStateChanged;
+            const { createRouter } = setupRouterMock();
+            const setup = setupPrefetch(createRouter, [pageRef], mockPrefetchConfig);
+            const service = setup.run();
+            service.adgMap.set(() => ({}), {
+                addresses: [],
+                resolverInputStatus: [],
+            });
+            service.stop();
+            await waitForExpect(() => {
+                expect(onStateChanged).toHaveBeenCalledTimes(2);
+                expect(onStateChanged).toHaveBeenNthCalledWith(1, expect.objectContaining({ state: 'running' }));
+                expect(onStateChanged).toHaveBeenNthCalledWith(2, expect.objectContaining({ state: 'stopped' }));
+                onStateChanged.mockClear();
+                service.stop();
+                expect(onStateChanged).toHaveBeenCalledTimes(0);
+            });
+        });
+        it('call instrumentation counter correctly', async () => {
+            expect.assertions(1);
+            const { createRouter } = setupRouterMock();
+            setupPrefetch(createRouter, [pageRef], mockPrefetchConfig).run();
+            await waitForExpect(() => {
+                expect(mockInstrumentation.incrementCounter).toBeCalledWith('prefetch.route-success', 1);
+            });
+        });
+    });
+    describe('unexpected scenarios', () => {
+        const { createRouter } = setupRouterMock();
+        const pageRef = createPageRef();
+        it('gracefully handles router result with no viewset', async () => {
+            expect.assertions(5);
+            const { onStateChanged, onAddressProcessed } = mockPrefetchConfig;
+            createRouter.mockImplementationOnce(() => {
+                return {
+                    resolveView: jest
+                        .fn()
+                        .mockImplementation(() => {
+                        return Promise.resolve({ viewset: {} });
+                    }),
+                };
+            });
+            const setup = setupPrefetch(createRouter, [pageRef], mockPrefetchConfig);
+            setup.run();
+            await waitForExpect(() => {
+                expect(onStateChanged).toBeCalledTimes(2);
+                expect(onStateChanged).toHaveBeenNthCalledWith(1, expect.objectContaining({ state: 'running' }));
+                expect(onStateChanged).toHaveBeenNthCalledWith(2, expect.objectContaining({ state: 'done' }));
+                expect(onAddressProcessed).toBeCalledTimes(1);
+                expect(onAddressProcessed).toHaveBeenCalledWith(expect.objectContaining({
+                    state: 'rejected',
+                    reasons: [
+                        expect.stringContaining('No ADG module found for given address'),
+                    ],
+                }));
+            });
+        });
+        it('calls onStateChanged with "error" when bulk resolver error state with invalid index', async () => {
+            expect.assertions(2);
+            const { onStateChanged } = mockPrefetchConfig;
+            jest.spyOn(ResolverApi, 'getBulkAdgResolver').mockImplementationOnce((_adg, _inputs, callbacks) => {
+                invokeCallbackWithState(callbacks.bulkResolutionStatusCb, 'running');
+                invokeCallbackWithState(callbacks.bulkResolutionStatusCb, 'done', ['nothing good'], 1);
+                return { start: jest.fn(), stop: jest.fn() };
+            });
+            const setup = setupPrefetch(createRouter, [pageRef], mockPrefetchConfig);
+            setup.run();
+            await waitForExpect(() => {
+                expect(onStateChanged).toBeCalledTimes(2);
+                expect(onStateChanged).toHaveBeenLastCalledWith(expect.objectContaining({
+                    state: 'error',
+                    message: expect.stringContaining('Invalid index provided by resolver'),
+                }));
+            });
+        });
+        it('handles onAddressProcessed that throws error', async () => {
+            expect.assertions(2);
+            const { createRouter } = setupRouterMock();
+            const onAddressProcessed = mockPrefetchConfigStatusError.onAddressProcessed;
+            const onStateChanged = mockPrefetchConfigStatusError.onStateChanged;
+            const setup = setupPrefetch(createRouter, [pageRef], mockPrefetchConfigStatusError);
+            setup.run();
+            await waitForExpect(() => {
+                expect(onAddressProcessed).toThrowError();
+                expect(onStateChanged).toBeCalled();
+            });
+        });
+        it('handles onStateChanged that throws error', async () => {
+            expect.assertions(1);
+            const { createRouter } = setupRouterMock();
+            const onStateChanged = mockPrefetchConfigStateError.onStateChanged;
+            const setup = setupPrefetch(createRouter, [pageRef], mockPrefetchConfigStateError);
+            setup.run();
+            await waitForExpect(() => {
+                expect(onStateChanged).toThrowError();
+            });
+        });
+        it('calls onStateChanged with "error" when bulk resolver emits an invalid status', async () => {
+            expect.assertions(3);
+            const { onStateChanged } = mockPrefetchConfig;
+            jest.spyOn(ResolverApi, 'getBulkAdgResolver').mockImplementationOnce((_adg, _inputs, callbacks) => {
+                invokeCallbackWithState(callbacks.bulkResolutionStatusCb, 'running');
+                invokeCallbackWithState(callbacks.bulkResolutionStatusCb, 'arfdarf');
+                return { start: jest.fn(), stop: jest.fn() };
+            });
+            const setup = setupPrefetch(createRouter, [pageRef], mockPrefetchConfig);
+            const service = setup.run();
+            await waitForExpect(() => {
+                expect(onStateChanged).toBeCalledTimes(2);
+                expect(onStateChanged).toHaveBeenLastCalledWith(expect.objectContaining({
+                    state: 'error',
+                    message: expect.stringContaining('Unexpected resolution status'),
+                }));
+                expect(service.resolutionGroups[0].bulkResolver).not.toBe(undefined);
+            });
+        });
+        it('should gracefully handle a module importer that throws an exception', async () => {
+            expect.assertions(7);
+            const pageRef1 = createPageRef('action1');
+            const pageRef2 = createPageRef('action2');
+            const pageRef3 = createPageRef('action3');
+            const pageRef2Reason = 'Module importer error';
+            const pageRef1Importer = () => Promise.resolve(createAdgModule());
+            const pageRef2Importer = () => Promise.reject(new Error(pageRef2Reason));
+            const pageRef3Importer = () => Promise.reject();
+            const { onAddressProcessed, onStateChanged } = mockPrefetchConfig;
+            const { createRouter } = setupRouterMock((address) => {
+                const result = defaultRoutingResult(address);
+                const importer = address == pageRef1
+                    ? pageRef1Importer
+                    : (address == pageRef2 && pageRef2Importer) ||
+                        pageRef3Importer;
+                return {
+                    ...result,
+                    viewset: {
+                        komaci: importer,
+                    },
+                };
+            });
+            const setup = setupPrefetch(createRouter, [pageRef1, pageRef2, pageRef3], mockPrefetchConfig);
+            setup.run();
+            await waitForExpect(() => {
+                expect(onStateChanged).toBeCalledTimes(2);
+                expect(onStateChanged).toHaveBeenNthCalledWith(1, expect.objectContaining({ state: 'running' }));
+                expect(onStateChanged).toHaveBeenNthCalledWith(2, expect.objectContaining({ state: 'done' }));
+                expect(onAddressProcessed).toBeCalledTimes(3);
+                expect(onAddressProcessed).toHaveBeenNthCalledWith(1, expect.objectContaining({
+                    state: 'rejected',
+                    address: pageRef2,
+                    reasons: expect.arrayContaining([
+                        'Unexpected exception processing routing result: ' +
+                            pageRef2Reason,
+                    ]),
+                }));
+                expect(onAddressProcessed).toHaveBeenNthCalledWith(2, expect.objectContaining({
+                    state: 'rejected',
+                    address: pageRef3,
+                    reasons: expect.arrayContaining([
+                        expect.stringContaining('Unknown exception processing routing result.'),
+                    ]),
+                }));
+                expect(onAddressProcessed).toHaveBeenNthCalledWith(3, expect.objectContaining({
+                    state: 'completed',
+                    address: pageRef1,
+                }));
+            });
+        });
+        describe('invalid routers or invalid routes', () => {
+            const pageRefs = [createPageRef('action1'), createPageRef('action2')];
+            it('should call onAddressProcessed with rejected if router is invalid', async () => {
+                expect.assertions(6);
+                const { createRouter } = setupRouterMock();
+                const router = createRouter();
+                router.resolveView.mockImplementation(() => {
+                    throw new Error('Invalid route.');
+                });
+                const { onStateChanged, onAddressProcessed } = mockPrefetchConfig;
+                getPrefetchService(router, pageRefs, mockPrefetchConfig);
+                await waitForExpect(() => {
+                    expect(onAddressProcessed).toBeCalledTimes(2);
+                    expect(onAddressProcessed.mock.calls[0][0]).toEqual({
+                        address: pageRefs[0],
+                        state: 'rejected',
+                        reasons: ['Unexpected exception during routing: Invalid route.'],
+                    });
+                    expect(onAddressProcessed.mock.calls[1][0]).toEqual({
+                        address: pageRefs[1],
+                        state: 'rejected',
+                        reasons: ['Unexpected exception during routing: Invalid route.'],
+                    });
+                    expect(onStateChanged).toBeCalledTimes(2);
+                    expect(onStateChanged.mock.calls[0][0]).toEqual({
+                        state: 'running',
+                        abandoned: [],
+                    });
+                    expect(onStateChanged.mock.calls[1][0]).toEqual({
+                        state: 'done',
+                        abandoned: [],
+                        message: 'no processable addresses, do not bulkResolve and set state to "done"',
+                    });
+                });
+            });
+            it('should call onAddressProcessed with rejected if one route is invalid', async () => {
+                expect.assertions(6);
+                const { createRouter } = setupRouterMock();
+                const router = createRouter();
+                router.resolveView.mockImplementationOnce(() => {
+                    throw new Error('Invalid route.');
+                });
+                const { onStateChanged, onAddressProcessed } = mockPrefetchConfig;
+                getPrefetchService(router, pageRefs, mockPrefetchConfig);
+                await waitForExpect(() => {
+                    expect(onAddressProcessed).toBeCalledTimes(2);
+                    expect(onAddressProcessed.mock.calls[0][0]).toEqual({
+                        address: pageRefs[0],
+                        state: 'rejected',
+                        reasons: ['Unexpected exception during routing: Invalid route.'],
+                    });
+                    expect(onAddressProcessed.mock.calls[1][0]).toEqual({
+                        address: pageRefs[1],
+                        state: 'completed',
+                        reasons: [],
+                    });
+                    expect(onStateChanged).toBeCalledTimes(2);
+                    expect(onStateChanged.mock.calls[0][0]).toEqual({
+                        state: 'running',
+                        abandoned: [],
+                    });
+                    expect(onStateChanged.mock.calls[1][0]).toEqual({
+                        state: 'done',
+                        abandoned: [],
+                        message: '',
+                    });
+                });
+            });
+        });
+    });
+    describe('prefetch two addresses and call bulkResolver', () => {
+        const pageRef1 = createPageRef('action1');
+        const pageRef2 = createPageRef('action1', '2');
+        const adgModule = createAdgModule();
+        const adgFunction = adgModule.default;
+        // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+        const adgModuleImporter = () => Promise.resolve(adgModule);
+        const init = () => setupRouterMock((address) => {
+            const result = defaultRoutingResult(address);
+            return {
+                ...result,
+                viewset: {
+                    komaci: adgModuleImporter,
+                },
+            };
+        });
+        describe('pageRef1 && pageRef2 => adgModule1', () => {
+            it('calls bulkResolver once with two adgInputs', async () => {
+                expect.assertions(3);
+                const { createRouter } = init();
+                const mockGetBulkAdgResolver = jest.spyOn(ResolverApi, 'getBulkAdgResolver');
+                const setup = setupPrefetch(createRouter, [pageRef1, pageRef2], mockPrefetchConfig);
+                setup.run();
+                await waitForExpect(() => {
+                    expect(mockGetBulkAdgResolver).toHaveBeenCalledTimes(1);
+                    expect(mockGetBulkAdgResolver).toHaveBeenCalledWith(adgFunction, expect.arrayContaining([
+                        expect.objectContaining({
+                            context: { CurrentPageReference: pageRef1 },
+                        }),
+                        expect.objectContaining({
+                            context: { CurrentPageReference: pageRef2 },
+                        }),
+                    ]), expect.anything(), {
+                        downloadImageFunc: undefined,
+                        instrumentationCtx: {
+                            isRootActivitySampled: true,
+                            rootId: 'abcd-1234',
+                        },
+                        MaxResolutionDepth: 512,
+                        WireTimeout: 180 * 1000,
+                        WireSlowRunningTimeout: 30 * 1000,
+                    });
+                    expect(mockGetBulkAdgResolver.mock.calls[0][1]).toHaveLength(2);
+                });
+            });
+        });
+        describe('pageRef1 & pageRef2 => adgModule1, pageRef2 => raises resolver error', () => {
+            const pageRef1 = createPageRef('action1');
+            const pageRef2 = createPageRef('action2');
+            const adgModule1 = createAdgModule();
+            const adgFunction1 = adgModule1.default;
+            const adgModuleImporter1 = () => Promise.resolve(adgModule1);
+            const { onAddressProcessed } = mockPrefetchConfig;
+            it('calls onAddressProcessed twice: pageRef1 => completed, pageRef2 => rejected', async () => {
+                expect.assertions(5);
+                const { createRouter } = setupRouterMock((address) => {
+                    const result = defaultRoutingResult(address);
+                    return {
+                        ...result,
+                        viewset: {
+                            komaci: adgModuleImporter1,
+                        },
+                    };
+                });
+                const mockGetBulkAdgResolver = jest.spyOn(ResolverApi, 'getBulkAdgResolver').mockImplementationOnce((_adg, inputs, callbacks) => {
+                    invokeCallbackWithState(callbacks.bulkResolutionStatusCb, 'done', [
+                        'Error processing input',
+                        JSON.stringify(inputs[1], null, 4),
+                    ], 1);
+                    invokeCallbackWithState(callbacks.bulkResolutionStatusCb, 'done');
+                    return { start: jest.fn(), stop: jest.fn() };
+                });
+                const setup = setupPrefetch(createRouter, [pageRef1, pageRef2], mockPrefetchConfig);
+                setup.run();
+                await waitForExpect(() => {
+                    expect(mockGetBulkAdgResolver).toBeCalledTimes(1);
+                    expect(mockGetBulkAdgResolver).toHaveBeenNthCalledWith(1, adgFunction1, expect.arrayContaining([
+                        expect.objectContaining({
+                            context: { CurrentPageReference: pageRef1 },
+                        }),
+                    ]), expect.anything(), {
+                        downloadImageFunc: undefined,
+                        instrumentationCtx: {
+                            isRootActivitySampled: true,
+                            rootId: 'abcd-1234',
+                        },
+                        MaxResolutionDepth: 512,
+                        WireTimeout: 180 * 1000,
+                        WireSlowRunningTimeout: 30 * 1000,
+                    });
+                    expect(onAddressProcessed).toHaveBeenCalledTimes(2);
+                    expect(onAddressProcessed).toHaveBeenNthCalledWith(1, expect.objectContaining({
+                        state: 'rejected',
+                        address: pageRef2,
+                    }));
+                    expect(onAddressProcessed).toHaveBeenNthCalledWith(2, expect.objectContaining({
+                        state: 'completed',
+                        address: pageRef1,
+                    }));
+                });
+            });
+        });
+        describe('pageRef1 => adgModule1, pageRef2 => adgModule2', () => {
+            const pageRef1 = createPageRef('action1');
+            const pageRef2 = createPageRef('action2');
+            const adgModule1 = createAdgModule();
+            const adgModule2 = createAdgModule();
+            const adgFunction1 = adgModule1.default;
+            const adgFunction2 = adgModule2.default;
+            const adgModuleImporter1 = () => Promise.resolve(adgModule1);
+            const adgModuleImporter2 = () => Promise.resolve(adgModule2);
+            const init = () => setupRouterMock((address) => {
+                const result = defaultRoutingResult(address);
+                return {
+                    ...result,
+                    viewset: {
+                        komaci: address.attributes.apiName == 'action1'
+                            ? adgModuleImporter1
+                            : adgModuleImporter2,
+                    },
+                };
+            });
+            it('calls bulkResolver twice with one adgInput each time', async () => {
+                expect.assertions(3);
+                const { createRouter } = init();
+                const mockGetBulkAdgResolver = jest.spyOn(ResolverApi, 'getBulkAdgResolver');
+                const setup = setupPrefetch(createRouter, [pageRef1, pageRef2], mockPrefetchConfig);
+                setup.run();
+                await waitForExpect(() => {
+                    expect(mockGetBulkAdgResolver).toBeCalledTimes(2);
+                    expect(mockGetBulkAdgResolver).toHaveBeenNthCalledWith(1, adgFunction1, expect.arrayContaining([
+                        expect.objectContaining({
+                            context: { CurrentPageReference: pageRef1 },
+                        }),
+                    ]), expect.anything(), {
+                        downloadImageFunc: undefined,
+                        instrumentationCtx: {
+                            isRootActivitySampled: true,
+                            rootId: 'abcd-1234',
+                        },
+                        MaxResolutionDepth: 512,
+                        WireTimeout: 180 * 1000,
+                        WireSlowRunningTimeout: 30 * 1000,
+                    });
+                    expect(mockGetBulkAdgResolver).toHaveBeenNthCalledWith(2, adgFunction2, expect.arrayContaining([
+                        expect.objectContaining({
+                            context: { CurrentPageReference: pageRef2 },
+                        }),
+                    ]), expect.anything(), {
+                        downloadImageFunc: undefined,
+                        instrumentationCtx: {
+                            isRootActivitySampled: true,
+                            rootId: 'abcd-1234',
+                        },
+                        MaxResolutionDepth: 512,
+                        WireTimeout: 180 * 1000,
+                        WireSlowRunningTimeout: 30 * 1000,
+                    });
+                });
+            });
+            const { onStateChanged, onAddressProcessed } = mockPrefetchConfig;
+            it('prefetch state waits to emit done until all resolvers are done', async () => {
+                expect.assertions(7);
+                const { createRouter } = init();
+                const mockGetBulkAdgResolver = jest.spyOn(ResolverApi, 'getBulkAdgResolver');
+                const setup = setupPrefetch(createRouter, [pageRef1, pageRef2], mockPrefetchConfig);
+                setup.run();
+                await waitForExpect(() => {
+                    expect(mockGetBulkAdgResolver).toBeCalledTimes(2);
+                    expect(onStateChanged).toBeCalledTimes(2);
+                    expect(onStateChanged).toBeCalledWith(expect.objectContaining({
+                        state: 'running',
+                    }));
+                    expect(onAddressProcessed).toBeCalledTimes(2);
+                    expect(onAddressProcessed).toHaveBeenCalledWith(expect.objectContaining({
+                        state: 'completed',
+                        address: pageRef1,
+                    }));
+                    expect(onAddressProcessed).toHaveBeenCalledWith(expect.objectContaining({
+                        state: 'completed',
+                        address: pageRef2,
+                    }));
+                    expect(onStateChanged).toHaveBeenLastCalledWith(expect.objectContaining({
+                        state: 'done',
+                    }));
+                });
+            });
+        });
+        describe('pageRef1 => adgModule1, pageRef2 => null', () => {
+            const pageRef1 = createPageRef('action1');
+            const pageRef2 = createPageRef('action2');
+            const adgModule1 = createAdgModule();
+            const adgFunction1 = adgModule1.default;
+            const adgModuleImporter1 = () => Promise.resolve(adgModule1);
+            const { onAddressProcessed, onStateChanged } = mockPrefetchConfig;
+            it('calls onAddressedProcessed twice: pageRef1 => completed, pageRef2 => rejected', async () => {
+                const { createRouter } = setupRouterMock((address) => {
+                    const result = defaultRoutingResult(address);
+                    const viewset = address.attributes.apiName == 'action1'
+                        ? {
+                            komaci: adgModuleImporter1,
+                        }
+                        : {};
+                    return {
+                        ...result,
+                        viewset,
+                    };
+                });
+                const mockGetBulkAdgResolver = jest.spyOn(ResolverApi, 'getBulkAdgResolver');
+                const setup = setupPrefetch(createRouter, [pageRef1, pageRef2], mockPrefetchConfig);
+                expect.assertions(6);
+                setup.run();
+                await waitForExpect(() => {
+                    expect(mockGetBulkAdgResolver).toBeCalledTimes(1);
+                    expect(mockGetBulkAdgResolver).toHaveBeenNthCalledWith(1, adgFunction1, expect.arrayContaining([
+                        expect.objectContaining({
+                            context: { CurrentPageReference: pageRef1 },
+                        }),
+                    ]), expect.anything(), {
+                        downloadImageFunc: undefined,
+                        instrumentationCtx: {
+                            isRootActivitySampled: true,
+                            rootId: 'abcd-1234',
+                        },
+                        MaxResolutionDepth: 512,
+                        WireTimeout: 180 * 1000,
+                        WireSlowRunningTimeout: 30 * 1000,
+                    });
+                    expect(onStateChanged).toHaveBeenCalledTimes(2);
+                    expect(onAddressProcessed).toHaveBeenCalledTimes(2);
+                    expect(onAddressProcessed).toHaveBeenNthCalledWith(1, expect.objectContaining({
+                        state: 'rejected',
+                        address: pageRef2,
+                    }));
+                    expect(onAddressProcessed).toHaveBeenNthCalledWith(2, expect.objectContaining({
+                        state: 'completed',
+                        address: pageRef1,
+                    }));
+                });
+            });
+        });
+    });
+    describe('PrefetchConfig Option Tests', () => {
+        describe('maxConcurrent Tests', () => {
+            describe('prefetch two addresses and call bulkResolver with maxConcurrent', () => {
+                const pageRef1_1 = createPageRef('action1');
+                const pageRef1_2 = createPageRef('action1', '2');
+                const pageRef2_1 = createPageRef('action2');
+                const pageRef2_2 = createPageRef('action2', '2');
+                const adgModule1 = createAdgModule();
+                const adgModule2 = createAdgModule();
+                const adgFunction1 = adgModule1.default;
+                const adgFunction2 = adgModule2.default;
+                const adgModuleImporter1 = () => Promise.resolve(adgModule1);
+                const adgModuleImporter2 = () => Promise.resolve(adgModule2);
+                const init = () => setupRouterMock((address) => {
+                    const result = defaultRoutingResult(address);
+                    return {
+                        ...result,
+                        viewset: {
+                            komaci: address.attributes.apiName == 'action1'
+                                ? adgModuleImporter1
+                                : adgModuleImporter2,
+                        },
+                    };
+                });
+                describe('pageRef1 && pageRef2 => adgModule1, but maxConcurrent: 1', () => {
+                    it('calls bulkResolver twice with two adgInputs', async () => {
+                        const prefetchConfigWithConcurrent = {
+                            ...mockPrefetchConfig,
+                            maxConcurrent: 1,
+                        };
+                        expect.assertions(5);
+                        const { createRouter } = init();
+                        const mockGetBulkAdgResolver = jest.spyOn(ResolverApi, 'getBulkAdgResolver');
+                        const setup = setupPrefetch(createRouter, [pageRef1_1, pageRef1_2], prefetchConfigWithConcurrent);
+                        setup.run();
+                        await waitForExpect(() => {
+                            expect(mockGetBulkAdgResolver).toHaveBeenCalledTimes(2);
+                            expect(mockGetBulkAdgResolver).toHaveBeenCalledWith(adgFunction1, expect.arrayContaining([
+                                expect.objectContaining({
+                                    context: { CurrentPageReference: pageRef1_1 },
+                                }),
+                            ]), expect.anything(), {
+                                downloadImageFunc: undefined,
+                                instrumentationCtx: {
+                                    isRootActivitySampled: true,
+                                    rootId: 'abcd-1234',
+                                },
+                                MaxResolutionDepth: 512,
+                                WireTimeout: 180 * 1000,
+                                WireSlowRunningTimeout: 30 * 1000,
+                            });
+                            expect(mockGetBulkAdgResolver).toHaveBeenCalledWith(adgFunction1, expect.arrayContaining([
+                                expect.objectContaining({
+                                    context: { CurrentPageReference: pageRef1_2 },
+                                }),
+                            ]), expect.anything(), {
+                                downloadImageFunc: undefined,
+                                instrumentationCtx: {
+                                    isRootActivitySampled: true,
+                                    rootId: 'abcd-1234',
+                                },
+                                MaxResolutionDepth: 512,
+                                WireTimeout: 180 * 1000,
+                                WireSlowRunningTimeout: 30 * 1000,
+                            });
+                            expect(mockGetBulkAdgResolver.mock.calls[0][1]).toHaveLength(1);
+                            expect(mockGetBulkAdgResolver.mock.calls[1][1]).toHaveLength(1);
+                        });
+                    });
+                });
+                describe('pageRef1 && pageRef2 => adgModule1 and pageRef3 && pageRef4 => adgModule2, but maxConcurrent: 3', () => {
+                    it('calls bulkResolver twice with two adgInputs', async () => {
+                        const prefetchConfigWithConcurrent = {
+                            ...mockPrefetchConfig,
+                            maxConcurrent: 3,
+                        };
+                        expect.assertions(6);
+                        const { createRouter } = init();
+                        const mockGetBulkAdgResolver = jest.spyOn(ResolverApi, 'getBulkAdgResolver');
+                        const setup = setupPrefetch(createRouter, [pageRef1_1, pageRef2_1, pageRef1_2, pageRef2_2], prefetchConfigWithConcurrent);
+                        const prefetchService = setup.run();
+                        await waitForExpect(() => {
+                            expect(mockGetBulkAdgResolver).toHaveBeenCalledTimes(2);
+                            expect(mockGetBulkAdgResolver).toHaveBeenCalledWith(adgFunction1, expect.arrayContaining([
+                                expect.objectContaining({
+                                    context: { CurrentPageReference: pageRef1_1 },
+                                }),
+                                expect.objectContaining({
+                                    context: { CurrentPageReference: pageRef1_2 },
+                                }),
+                            ]), expect.anything(), {
+                                downloadImageFunc: undefined,
+                                instrumentationCtx: {
+                                    isRootActivitySampled: true,
+                                    rootId: 'abcd-1234',
+                                },
+                                MaxResolutionDepth: 512,
+                                WireTimeout: 180 * 1000,
+                                WireSlowRunningTimeout: 30 * 1000,
+                            });
+                            expect(mockGetBulkAdgResolver).toHaveBeenCalledWith(adgFunction2, expect.arrayContaining([
+                                expect.objectContaining({
+                                    context: { CurrentPageReference: pageRef2_1 },
+                                }),
+                                expect.objectContaining({
+                                    context: { CurrentPageReference: pageRef2_2 },
+                                }),
+                            ]), expect.anything(), {
+                                downloadImageFunc: undefined,
+                                instrumentationCtx: {
+                                    isRootActivitySampled: true,
+                                    rootId: 'abcd-1234',
+                                },
+                                MaxResolutionDepth: 512,
+                                WireTimeout: 180 * 1000,
+                                WireSlowRunningTimeout: 30 * 1000,
+                            });
+                            expect(mockGetBulkAdgResolver.mock.calls[0][1]).toHaveLength(2);
+                            expect(mockGetBulkAdgResolver.mock.calls[1][1]).toHaveLength(2);
+                            expect(prefetchService.resolutionGroups[1].bulkResolver).toBe(undefined);
+                        });
+                    });
+                });
+            });
+        });
+        describe('highVolumePriming Tests', () => {
+            it('Only assigns 1 address to each AdgModule for resolution', async () => {
+                const pageRef1 = createPageRef('action1');
+                const adgModule1 = createAdgModule();
+                const adgFunction1 = adgModule1.default;
+                let addressesPrimedResolve;
+                let addressCount = 0;
+                const addressesPrimedPromise = new Promise((resolve) => {
+                    addressesPrimedResolve = resolve;
+                });
+                const adgModuleImporter1 = () => {
+                    addressCount++;
+                    if (addressCount >= 2) {
+                        addressesPrimedResolve();
+                    }
+                    return Promise.resolve(adgModule1);
+                };
+                const { createRouter } = setupRouterMock((address) => {
+                    const result = defaultRoutingResult(address);
+                    return {
+                        ...result,
+                        viewset: {
+                            komaci: adgModuleImporter1,
+                        },
+                    };
+                });
+                const prefetchConfigWithHighVolumePriming = {
+                    highVolumePriming: true,
+                };
+                const setup = setupPrefetch(createRouter, [pageRef1, pageRef1], prefetchConfigWithHighVolumePriming);
+                const prefetchService = setup.run();
+                await addressesPrimedPromise;
+                expect(prefetchService['adgMap'].size).toEqual(1);
+                expect(prefetchService['adgMap'].get(adgFunction1)).toHaveLength(1);
+            });
+        });
+    });
+    describe('onStateChanged should be called with errorMessage', () => {
+        const { createRouter } = setupRouterMock();
+        const pageRef = createPageRef();
+        it('calls onStateChanged with error message', async () => {
+            expect.assertions(3);
+            const { onStateChanged } = mockPrefetchConfig;
+            const ERROR = 'I am error';
+            jest.spyOn(ResolverApi, 'getBulkAdgResolver').mockImplementationOnce((_adg, inputs, callbacks) => {
+                invokeCallbackWithState(callbacks.bulkResolutionStatusCb, 'running');
+                invokeCallbackWithState(callbacks.bulkResolutionStatusCb, 'done', [
+                    ERROR,
+                ]);
+                return { start: jest.fn(), stop: jest.fn() };
+            });
+            const setup = setupPrefetch(createRouter, [pageRef], mockPrefetchConfig);
+            const service = setup.run();
+            await waitForExpect(() => {
+                expect(onStateChanged).toBeCalledTimes(2);
+                expect(onStateChanged).toHaveBeenLastCalledWith(expect.objectContaining({
+                    state: 'done',
+                    message: expect.stringContaining(ERROR),
+                }));
+                expect(service.resolutionGroups[0].bulkResolver).not.toBe(undefined);
+                onStateChanged.mockClear();
+                service.stop();
+            });
+        });
+    });
+    describe('handle invalid state transitions', () => {
+        const { createRouter } = setupRouterMock();
+        const pageRef = createPageRef();
+        it('onStateChanged should only be called with "stopped" after status "done"', async () => {
+            const expected = ['running', 'done', 'stopped'];
+            expect.assertions(expected.length + 2);
+            const setup = setupPrefetch(createRouter, [pageRef], mockPrefetchConfig);
+            const service = setup.run();
+            const { onStateChanged } = mockPrefetchConfig;
+            jest.spyOn(ResolverApi, 'getBulkAdgResolver').mockImplementationOnce((_adg, _inputs, callbacks) => {
+                // prefetch in running
+                invokeCallbackWithState(callbacks.bulkResolutionStatusCb, 'done'); // allowed
+                invokeCallbackWithState(callbacks.bulkResolutionStatusCb, 'running'); // ignored
+                invokeCallbackWithState(callbacks.bulkResolutionStatusCb, 'done'); // ignored
+                service.stop();
+                service.onUnexpectedCondition('Should be ignored'); // ignored
+                invokeCallbackWithState(callbacks.bulkResolutionStatusCb, 'running'); // ignored
+                invokeCallbackWithState(callbacks.bulkResolutionStatusCb, 'done'); // ignored
+                return { start: jest.fn(), stop: jest.fn() };
+            });
+            return await waitForExpect(() => {
+                expect(onStateChanged).toBeCalledTimes(expected.length);
+                expected.forEach((expectedState, idx) => {
+                    expect(onStateChanged).toHaveBeenNthCalledWith(idx + 1, expect.objectContaining({
+                        state: expectedState,
+                    }));
+                });
+                expect(service.resolutionGroups[0].bulkResolver).not.toBe(undefined);
+                onStateChanged.mockClear();
+                service.stop();
+            }, 0);
+        });
+        it('onStateChanged "running" -> "error" -> "done" -> "stopped"', async () => {
+            const expected = ['running', 'error', 'done', 'stopped'];
+            expect.assertions(expected.length + 2);
+            const setup = setupPrefetch(createRouter, [pageRef], mockPrefetchConfig);
+            const service = setup.run();
+            const { onStateChanged } = mockPrefetchConfig;
+            jest.spyOn(ResolverApi, 'getBulkAdgResolver').mockImplementationOnce((_adg, _inputs, callbacks) => {
+                // prefetch in running
+                service.onUnexpectedCondition('should go through'); // allowed
+                invokeCallbackWithState(callbacks.bulkResolutionStatusCb, 'running'); // ignored
+                invokeCallbackWithState(callbacks.bulkResolutionStatusCb, 'done'); // allowed
+                service.onUnexpectedCondition('Should be ignored 1'); // ignored
+                service.stop(); // allowed
+                invokeCallbackWithState(callbacks.bulkResolutionStatusCb, 'done'); // ignored
+                service.onUnexpectedCondition('Should be ignored 2'); // ignored
+                invokeCallbackWithState(callbacks.bulkResolutionStatusCb, 'running'); // ignored
+                return { start: jest.fn(), stop: jest.fn() };
+            });
+            return await waitForExpect(() => {
+                expect(onStateChanged).toBeCalledTimes(expected.length);
+                expected.forEach((expectedState, idx) => {
+                    expect(onStateChanged).toHaveBeenNthCalledWith(idx + 1, expect.objectContaining({
+                        state: expectedState,
+                    }));
+                });
+                expect(service.resolutionGroups[0].bulkResolver).not.toBe(undefined);
+                onStateChanged.mockClear();
+                service.stop();
+            }, 0);
+        });
+    });
+});
+//# sourceMappingURL=prefetchService.spec.js.map

package/build/__tests__/utils.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="jest" />
+import { PageReference, Router, RouterConfig, RoutingResult, Module } from 'lwr/router';
+import { createRouter } from '@lwrjs/router';
+import { PrefetchConfig } from '../modules/komaci/prefetchTypes/prefetchTypes';
+declare type RouterModule = {
+    createRouter: typeof createRouter;
+};
+export declare function defaultRoutingResult(address: PageReference): RoutingResult;
+export declare function setupRouterMock(resolveAddress?: (address: PageReference) => Partial<RoutingResult>): RouterModule;
+export declare function createPageRef(apiName?: string, recordId?: string, state?: Record<string, string | null>): PageReference;
+export declare function createAdgModule(): Module;
+export declare function createRoutingResult(address: PageReference, adgModule: Module | false): RoutingResult;
+export declare function setupPrefetch(createRouter: (config: RouterConfig) => Router<PageReference>, pageRefs: PageReference[] | undefined, config: PrefetchConfig): any;
+export declare const mockPrefetchConfig: {
+    onStateChanged: jest.Mock<any, any>;
+    onAddressProcessed: jest.Mock<any, any>;
+    downloadImage: undefined;
+    instrumentationContext: {
+        rootId: string;
+        isRootActivitySampled: boolean;
+    };
+};
+export declare const mockPrefetchConfigStatusError: PrefetchConfig;
+export declare const mockPrefetchConfigStateError: PrefetchConfig;
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/build/__tests__/utils.js

@@ -0,0 +1,118 @@
+import { createRouter } from '@lwrjs/router';
+import { getPrefetchService } from '../modules/komaci/prefetch/prefetch';
+import registerAdgFunction from 'komaci/registerAdgFunction';
+export function defaultRoutingResult(address) {
+    return createRoutingResult(address, createAdgModule());
+}
+export function setupRouterMock(resolveAddress = defaultRoutingResult) {
+    return {
+        createRouter: createRouter.mockImplementation((config) => {
+            return {
+                config,
+                resolveView: jest
+                    .fn()
+                    .mockImplementation((address) => {
+                    const { viewset } = resolveAddress(address);
+                    return Promise.resolve({
+                        viewset,
+                    });
+                }),
+            };
+        }),
+    };
+}
+export function createPageRef(apiName = 'action1', recordId = '1', state = {}) {
+    return {
+        type: 'standard__quickAction',
+        attributes: {
+            apiName,
+            recordId,
+            objectApiName: 'Account',
+        },
+        state,
+    };
+}
+export function createAdgModule() {
+    const emptyAdg = {
+        parentClass: undefined,
+        properties: {},
+        functions: [],
+        composition: () => [],
+    };
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const mockAdgModuleFunction = (fct) => emptyAdg;
+    return { default: registerAdgFunction(mockAdgModuleFunction) };
+}
+export function createRoutingResult(address, adgModule) {
+    const { state, attributes, attributes: { apiName, recordId, objectApiName }, type, } = address;
+    const viewset = (adgModule
+        ? {
+            default: {
+                module: () => Promise.resolve(adgModule),
+                specifier: '@salesforce/action/' + address.attributes.apiName,
+            },
+        }
+        : {});
+    return {
+        viewset,
+        pathMatch: `/${type}/${objectApiName}/${recordId}/${apiName}`,
+        route: {
+            id: type,
+            attributes: attributes,
+            state: state,
+            pageReference: address,
+        },
+        routeDefinition: {},
+    };
+}
+export function setupPrefetch(createRouter, pageRefs = [], config) {
+    const router = createRouter({});
+    return jest.fn(() => ({
+        createRouter,
+        pageRefs,
+        config,
+        run: () => {
+            return getPrefetchService(router, pageRefs, config);
+        },
+    }))();
+}
+export const mockPrefetchConfig = jest.fn(() => ({
+    onStateChanged: jest.fn(),
+    // .mockImplementation((status) =>
+    //     // eslint-disable-next-line no-console
+    //     console.log('onStateChanged', status.state, status.message),
+    // ),
+    onAddressProcessed: jest.fn(),
+    // .mockImplementation((status) =>
+    //     // eslint-disable-next-line no-console
+    // console.log('onAddresProcessed', status),
+    // ),
+    downloadImage: undefined,
+    instrumentationContext: {
+        rootId: 'abcd-1234',
+        isRootActivitySampled: true,
+    },
+}))();
+export const mockPrefetchConfigStatusError = {
+    onStateChanged: jest.fn(),
+    onAddressProcessed: jest.fn().mockImplementation(() => {
+        throw new Error(`Unexpected state status.`);
+    }),
+    downloadImage: undefined,
+    instrumentationContext: {
+        rootId: 'abcd-1234',
+        isRootActivitySampled: true,
+    },
+};
+export const mockPrefetchConfigStateError = {
+    onStateChanged: jest.fn().mockImplementation(() => {
+        throw new Error(`Unexpected state transition.`);
+    }),
+    onAddressProcessed: jest.fn(),
+    downloadImage: undefined,
+    instrumentationContext: {
+        rootId: 'abcd-1234',
+        isRootActivitySampled: true,
+    },
+};
+//# sourceMappingURL=utils.js.map

package/build/modules/komaci/prefetchService/prefetchService.js

@@ -32,7 +32,6 @@ export class PrefetchService {
         this._instrumentation = getInstrumentation('komaci');
         this._activity = this._instrumentation.startActivity('prefetch', this.apiOptions);
         this._size = addresses.length;
-        //FIXME: to use o11y.startActivity() when o11y available
         this._startTime = Date.now();
         this.prefetch(addresses);
     }
@@ -57,7 +56,7 @@ export class PrefetchService {
             return this.onRoutingResult(address, destination);
         })
             .then((value) => {
-            this._instrumentation.log(prefetchSchema, userSchemaData, this.apiOptions);
+            this._instrumentation.incrementCounter('prefetch.route-success', 1);
             return value;
         })
             .catch((err) => {

package/build/modules/komaci/prefetchTypes/prefetchTypes.d.ts

@@ -1,5 +1,5 @@
 import type { PageReference } from 'lwr/router';
-import type { ResolverExecutionState, AdgInput, AdgModule, IBulkResolver } from '@komaci/resolver';
+import type { ResolverExecutionState, AdgInput, AdgModuleExport, IBulkResolver } from '@komaci/resolver';
 import { InstrumentationContext } from 'o11y/dist/modules/o11y/client/interfaces';
 export declare const ERROR_PREFIX = "[komaci prefetch]";
 /**
@@ -8,7 +8,7 @@ export declare const ERROR_PREFIX = "[komaci prefetch]";
 export declare type AdgRoutingResult<TAddress = PageReference> = {
     address: TAddress;
     success: boolean;
-    adgModule?: AdgModule;
+    adgModule?: AdgModuleExport;
     reason?: string;
 };
 /**
@@ -26,6 +26,7 @@ export declare type AdgResolutionGroup<TAddress = PageReference> = {
 };
 export interface IPrefetchService {
     stop(): void;
+    getState(): PrefetchState;
 }
 export declare enum ResolutionStatusState {
     running = "running",

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@komaci/prefetch",
-    "version": "242.2.4",
+    "version": "244.0.0",
     "description": "Komaci prefetch service.",
     "homepage": "https://komaci.dev/",
     "repository": {
@@ -26,14 +26,14 @@
         "build/**/*.d.ts"
     ],
     "dependencies": {
-        "@komaci/module-shared": "242.2.4",
-        "@komaci/resolver": "242.2.4",
+        "@komaci/module-shared": "244.0.0",
+        "@komaci/resolver": "244.0.0",
         "@lwrjs/router": "0.6.0-alpha.15",
-        "o11y": "^240.7.0",
-        "o11y_schema": "^240.11.0"
+        "o11y": "^244.0.0",
+        "o11y_schema": "^244.0.0"
     },
     "devDependencies": {
-        "@komaci/types": "242.2.4",
+        "@komaci/types": "244.0.0",
         "wait-for-expect": "^3.0.2"
     }
 }