@cccsaurora/howler-ui 3.1.0-dev.1656 → 3.1.0-dev.1675

package/api/hit/comments/index.test.js

@@ -0,0 +1,47 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mockHdelete = vi.hoisted(() => vi.fn());
+const mockHget = vi.hoisted(() => vi.fn());
+const mockHpost = vi.hoisted(() => vi.fn());
+const mockHput = vi.hoisted(() => vi.fn());
+const mockJoinAllUri = vi.hoisted(() => vi.fn((...parts) => parts.join('/').replace(/\/+/g, '/')));
+const mockJoinUri = vi.hoisted(() => vi.fn((_base, _part) => '/api/v1/hit/hit-1/comments'));
+vi.mock('api', () => ({
+    hdelete: mockHdelete,
+    hget: mockHget,
+    hpost: mockHpost,
+    hput: mockHput,
+    joinAllUri: mockJoinAllUri,
+    joinUri: mockJoinUri
+}));
+vi.mock('api/hit', () => ({
+    uri: (id) => `/api/v1/hit/${id}`
+}));
+vi.mock('./react', () => ({
+    sentinel: 'react'
+}));
+import { del, get, post, put, react, uri } from './index';
+describe('hit comments API', () => {
+    beforeEach(() => {
+        mockHdelete.mockReset();
+        mockHget.mockReset();
+        mockHpost.mockReset();
+        mockHput.mockReset();
+        mockJoinAllUri.mockClear();
+        mockJoinUri.mockClear();
+    });
+    it('builds list and detail comment URIs', () => {
+        expect(uri('hit-1')).toBe('/api/v1/hit/hit-1/comments');
+        expect(uri('hit-1', 'comment-1')).toBe('/api/v1/hit/hit-1/comments/comment-1');
+    });
+    it('gets, creates, updates, and deletes hit comments', async () => {
+        await get('hit-1', 'comment-1');
+        await put('hit-1', 'comment-1', 'updated');
+        await post('hit-1', 'new comment');
+        await del('hit-1', ['comment-1']);
+        expect(mockHget).toHaveBeenCalledWith('/api/v1/hit/hit-1/comments/comment-1');
+        expect(mockHput).toHaveBeenCalledWith('/api/v1/hit/hit-1/comments/comment-1', { value: 'updated' });
+        expect(mockHpost).toHaveBeenCalledWith('/api/v1/hit/hit-1/comments', { value: 'new comment' });
+        expect(mockHdelete).toHaveBeenCalledWith('/api/v1/hit/hit-1/comments', ['comment-1']);
+        expect(react).toEqual({ sentinel: 'react' });
+    });
+});

package/api/hit/comments/react.test.d.ts

@@ -0,0 +1 @@
+export {};

package/api/hit/comments/react.test.js

@@ -0,0 +1,27 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mockHdelete = vi.hoisted(() => vi.fn());
+const mockHput = vi.hoisted(() => vi.fn());
+const mockJoinUri = vi.hoisted(() => vi.fn((base, part) => `${base}/${part}`));
+vi.mock('api', () => ({
+    hdelete: mockHdelete,
+    hput: mockHput,
+    joinUri: mockJoinUri
+}));
+vi.mock('api/hit/comments', () => ({
+    uri: (hit, comment) => `/api/v1/hit/${hit}/comments/${comment}`
+}));
+import { del, put, uri } from './react';
+describe('hit comment reactions API', () => {
+    beforeEach(() => {
+        mockHdelete.mockReset();
+        mockHput.mockReset();
+        mockJoinUri.mockClear();
+    });
+    it('builds nested reaction URIs and performs add/remove requests', async () => {
+        expect(uri('hit-1', 'comment-1')).toBe('/api/v1/hit/hit-1/comments/comment-1/react');
+        await put('hit-1', 'comment-1', 'thumbs_up');
+        await del('hit-1', 'comment-1');
+        expect(mockHput).toHaveBeenCalledWith('/api/v1/hit/hit-1/comments/comment-1/react', { type: 'thumbs_up' });
+        expect(mockHdelete).toHaveBeenCalledWith('/api/v1/hit/hit-1/comments/comment-1/react');
+    });
+});

package/api/hit/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/api/hit/index.test.js

@@ -0,0 +1,49 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mockHdelete = vi.hoisted(() => vi.fn());
+const mockHget = vi.hoisted(() => vi.fn());
+const mockHpost = vi.hoisted(() => vi.fn());
+const mockJoinAllUri = vi.hoisted(() => vi.fn((...parts) => parts.join('/').replace(/\/+/g, '/')));
+const mockJoinUri = vi.hoisted(() => vi.fn(() => '/api/v1/hit'));
+vi.mock('api', () => ({
+    hdelete: mockHdelete,
+    hget: mockHget,
+    hpost: mockHpost,
+    joinAllUri: mockJoinAllUri,
+    joinUri: mockJoinUri,
+    uri: () => '/api/v1'
+}));
+vi.mock('api/hit/assign', () => ({ sentinel: 'assign' }));
+vi.mock('api/hit/comments', () => ({ sentinel: 'comments' }));
+vi.mock('api/hit/labels', () => ({ sentinel: 'labels' }));
+vi.mock('api/hit/overwrite', () => ({ sentinel: 'overwrite' }));
+vi.mock('api/hit/transition', () => ({ sentinel: 'transition' }));
+import { assign, comments, del, get, labels, overwrite, post, transition, uri } from './index';
+describe('hit API', () => {
+    beforeEach(() => {
+        mockHdelete.mockReset();
+        mockHget.mockReset();
+        mockHpost.mockReset();
+        mockJoinAllUri.mockClear();
+        mockJoinUri.mockClear();
+    });
+    it('builds hit URIs', () => {
+        expect(uri()).toBe('/api/v1/hit');
+        expect(uri('abc')).toBe('/api/v1/hit/abc');
+    });
+    it('gets hits with metadata and sends bulk write operations with refresh params', async () => {
+        const refresh = new URLSearchParams({ refresh: 'true' });
+        await get('abc', ['one', 'two']);
+        await post([{ id: '1' }], 'true');
+        await del(['1', '2'], 'true');
+        expect(mockHget).toHaveBeenCalledWith('/api/v1/hit/abc', new URLSearchParams({ metadata: 'one,two' }));
+        expect(mockHpost).toHaveBeenCalledWith('/api/v1/hit', [{ id: '1' }], undefined, refresh);
+        expect(mockHdelete).toHaveBeenCalledWith('/api/v1/hit', ['1', '2'], undefined, refresh);
+    });
+    it('re-exports nested hit modules', () => {
+        expect(assign).toEqual({ sentinel: 'assign' });
+        expect(comments).toEqual({ sentinel: 'comments' });
+        expect(labels).toEqual({ sentinel: 'labels' });
+        expect(overwrite).toEqual({ sentinel: 'overwrite' });
+        expect(transition).toEqual({ sentinel: 'transition' });
+    });
+});

package/api/hit/labels.test.d.ts

@@ -0,0 +1 @@
+export {};

package/api/hit/labels.test.js

@@ -0,0 +1,29 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mockHdelete = vi.hoisted(() => vi.fn());
+const mockHput = vi.hoisted(() => vi.fn());
+const mockJoinAllUri = vi.hoisted(() => vi.fn((...parts) => parts.join('/').replace(/\/+/g, '/')));
+vi.mock('api', () => ({
+    hdelete: mockHdelete,
+    hput: mockHput,
+    joinAllUri: mockJoinAllUri
+}));
+vi.mock('api/hit', () => ({
+    uri: () => '/api/v1/hit'
+}));
+import { del, put, uri } from './labels';
+describe('hit labels API', () => {
+    beforeEach(() => {
+        mockHdelete.mockReset();
+        mockHput.mockReset();
+        mockJoinAllUri.mockClear();
+    });
+    it('builds the label URI and performs add/remove operations', async () => {
+        const refresh = new URLSearchParams({ refresh: 'wait_for' });
+        const body = { value: ['x'] };
+        expect(uri('id-1', 'insight')).toBe('/api/v1/hit/id-1/labels/insight');
+        await put('id-1', 'insight', body, 'wait_for');
+        await del('id-1', 'insight', body, 'wait_for');
+        expect(mockHput).toHaveBeenCalledWith('/api/v1/hit/id-1/labels/insight', body, undefined, refresh);
+        expect(mockHdelete).toHaveBeenCalledWith('/api/v1/hit/id-1/labels/insight', body, undefined, refresh);
+    });
+});

package/api/hit/overwrite.test.d.ts

@@ -0,0 +1 @@
+export {};

package/api/hit/overwrite.test.js

@@ -0,0 +1,23 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mockHput = vi.hoisted(() => vi.fn());
+const mockJoinAllUri = vi.hoisted(() => vi.fn((...parts) => parts.join('/').replace(/\/+/g, '/')));
+vi.mock('api', () => ({
+    hput: mockHput,
+    joinAllUri: mockJoinAllUri
+}));
+vi.mock('api/hit', () => ({
+    uri: () => '/api/v1/hit'
+}));
+import { put, uri } from './overwrite';
+describe('hit overwrite API', () => {
+    beforeEach(() => {
+        mockHput.mockReset();
+        mockJoinAllUri.mockClear();
+    });
+    it('builds the overwrite URI and forwards the overwrite body', async () => {
+        const refresh = new URLSearchParams({ refresh: 'true' });
+        expect(uri('id-1')).toBe('/api/v1/hit/id-1/overwrite');
+        await put('id-1', { status: 'open' }, 'true');
+        expect(mockHput).toHaveBeenCalledWith('/api/v1/hit/id-1/overwrite', { status: 'open' }, undefined, refresh);
+    });
+});

package/api/hit/transition.test.d.ts

@@ -0,0 +1 @@
+export {};

package/api/hit/transition.test.js

@@ -0,0 +1,24 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mockHpost = vi.hoisted(() => vi.fn());
+const mockJoinAllUri = vi.hoisted(() => vi.fn((...parts) => parts.join('/').replace(/\/+/g, '/')));
+vi.mock('api', () => ({
+    hpost: mockHpost,
+    joinAllUri: mockJoinAllUri
+}));
+vi.mock('api/hit', () => ({
+    uri: () => '/api/v1/hit'
+}));
+import { post, uri } from './transition';
+describe('hit transition API', () => {
+    beforeEach(() => {
+        mockHpost.mockReset();
+        mockJoinAllUri.mockClear();
+    });
+    it('builds the transition URI and posts the transition body', async () => {
+        const refresh = new URLSearchParams({ refresh: 'false' });
+        const body = { transition: 'resolve', data: { reason: 'done' } };
+        expect(uri('id-1')).toBe('/api/v1/hit/id-1/transition');
+        await post('id-1', body, 'false');
+        expect(mockHpost).toHaveBeenCalledWith('/api/v1/hit/id-1/transition', body, undefined, refresh);
+    });
+});

package/api/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/api/index.test.js

@@ -0,0 +1,137 @@
+/// <reference types="vitest" />
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mockClientFetch = vi.hoisted(() => vi.fn());
+const mockGetLocalStored = vi.hoisted(() => vi.fn());
+const mockRemoveLocalStored = vi.hoisted(() => vi.fn());
+const mockSaveLoginCredential = vi.hoisted(() => vi.fn());
+const mockSetLocalStored = vi.hoisted(() => vi.fn());
+const mockGetSessionStored = vi.hoisted(() => vi.fn());
+const mockSetSessionStored = vi.hoisted(() => vi.fn());
+const mockGetXSRFCookie = vi.hoisted(() => vi.fn());
+const mockRefreshLogin = vi.hoisted(() => vi.fn());
+vi.mock('rest/AxiosClient', () => ({
+    default: class AxiosClient {
+        fetch = mockClientFetch;
+    }
+}));
+vi.mock('utils/localStorage', () => ({
+    getStored: mockGetLocalStored,
+    removeStored: mockRemoveLocalStored,
+    saveLoginCredential: mockSaveLoginCredential,
+    setStored: mockSetLocalStored
+}));
+vi.mock('utils/sessionStorage', () => ({
+    getStored: mockGetSessionStored,
+    setStored: mockSetSessionStored
+}));
+vi.mock('utils/xsrf', () => ({
+    default: mockGetXSRFCookie
+}));
+vi.mock('api/action', () => ({ sentinel: 'action' }));
+vi.mock('api/analytic', () => ({ sentinel: 'analytic' }));
+vi.mock('api/auth', () => ({ login: { post: mockRefreshLogin }, sentinel: 'auth' }));
+vi.mock('api/configs', () => ({ sentinel: 'configs' }));
+vi.mock('api/dossier', () => ({ sentinel: 'dossier' }));
+vi.mock('api/help', () => ({ sentinel: 'help' }));
+vi.mock('api/hit', () => ({ sentinel: 'hit' }));
+vi.mock('api/notebook', () => ({ sentinel: 'notebook' }));
+vi.mock('api/overview', () => ({ sentinel: 'overview' }));
+vi.mock('api/search', () => ({ sentinel: 'search' }));
+vi.mock('api/socket', () => ({ sentinel: 'socket' }));
+vi.mock('api/template', () => ({ sentinel: 'template' }));
+vi.mock('api/user', () => ({ sentinel: 'user' }));
+vi.mock('api/v2', () => ({ sentinel: 'v2' }));
+vi.mock('api/view', () => ({ sentinel: 'view' }));
+import api, { hdelete, hfetch, hget, hpatch, hpost, hput, joinAllUri, joinParams, joinUri, setHeaders, uri } from './index';
+describe('api root module', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockGetXSRFCookie.mockReturnValue(null);
+        mockGetSessionStored.mockReturnValue({});
+        mockGetLocalStored.mockImplementation((key) => {
+            if (key === 'etag') {
+                return undefined;
+            }
+            return undefined;
+        });
+        history.pushState({}, '', '/hits?q=1');
+    });
+    it('exposes the API root path and nested modules', () => {
+        expect(uri()).toBe('/api/v1');
+        expect(api.action).toEqual({ sentinel: 'action' });
+        expect(api.auth).toEqual({ login: { post: mockRefreshLogin }, sentinel: 'auth' });
+        expect(api.v2).toEqual({ sentinel: 'v2' });
+    });
+    it('joins URIs, params, and headers consistently', () => {
+        expect(joinParams('/api/v1/hit', new URLSearchParams({ q: 'x' }))).toBe('/api/v1/hit?q=x');
+        expect(joinParams('/api/v1/hit?sort=asc', new URLSearchParams({ q: 'x' }))).toBe('/api/v1/hit?sort=asc&q=x');
+        expect(joinUri('hit', '123')).toBe('/api/v1/hit/123');
+        expect(joinUri('/socket', 'updates')).toBe('/socket/updates');
+        expect(joinAllUri('/api', 'v1', 'hit')).toBe('/api/v1/hit');
+        expect(setHeaders('abc')).toEqual({ 'If-Match': 'abc' });
+    });
+    it('performs a successful fetch and stores the returned ETag', async () => {
+        mockGetLocalStored.mockImplementation((key) => (key === 'app_token' ? 'token' : undefined));
+        mockGetSessionStored.mockReturnValue({ 'hit/hit123': '"old-etag"' });
+        mockGetXSRFCookie.mockReturnValue('csrf');
+        mockClientFetch.mockResolvedValue([{ api_response: { ok: true } }, 200, { etag: '"new-etag"' }]);
+        await expect(hfetch('hit/hit123', 'post', { key: 'value' })).resolves.toEqual({ ok: true });
+        expect(mockClientFetch).toHaveBeenCalledWith('/api/v1/hit/hit123', 'post', { key: 'value' }, undefined, expect.objectContaining({
+            'Content-Type': 'application/json',
+            'If-Match': '"old-etag"',
+            'X-XSRF-TOKEN': 'csrf',
+            Authorization: expect.any(String)
+        }));
+        expect(mockSetSessionStored).toHaveBeenCalledWith('etag', { 'hit/hit123': '"new-etag"' });
+    });
+    it('returns undefined for empty payloads and accepts 304 responses', async () => {
+        mockClientFetch
+            .mockResolvedValueOnce([undefined, 204, {}])
+            .mockResolvedValueOnce([{ api_response: { unchanged: true } }, 304, {}]);
+        await expect(hfetch('/analytic/1')).resolves.toBeUndefined();
+        await expect(hfetch('/analytic/1')).resolves.toEqual({ unchanged: true });
+    });
+    it('refreshes credentials after a 401 when a refresh token is available', async () => {
+        mockGetLocalStored.mockImplementation((key) => {
+            if (key === 'refresh_token')
+                return 'refresh-token';
+            if (key === 'provider')
+                return 'oidc';
+            return undefined;
+        });
+        mockRefreshLogin.mockResolvedValue({ app_token: 'new-token', refresh_token: 'new-refresh' });
+        mockClientFetch
+            .mockResolvedValueOnce([{ api_error_message: 'unauthorized' }, 401, {}])
+            .mockResolvedValueOnce([{ api_response: { retried: true } }, 200, {}]);
+        await expect(hfetch('/view/1')).resolves.toEqual({ retried: true });
+        expect(mockSetLocalStored).toHaveBeenCalledWith('next.location', '/hits');
+        expect(mockSetLocalStored).toHaveBeenCalledWith('next.search', '?q=1');
+        expect(mockRefreshLogin).toHaveBeenCalledWith({ refresh_token: 'refresh-token', provider: 'oidc' });
+        expect(mockSaveLoginCredential).toHaveBeenCalledWith({ app_token: 'new-token', refresh_token: 'new-refresh' });
+        expect(mockRemoveLocalStored).toHaveBeenCalledWith('next.location');
+        expect(mockRemoveLocalStored).toHaveBeenCalledWith('next.search');
+    });
+    it('clears credentials after a 401 when refresh is unavailable', async () => {
+        history.pushState({}, '', '/login');
+        mockClientFetch.mockResolvedValue([{ api_error_message: 'unauthorized' }, 401, {}]);
+        await expect(hfetch('/auth/login')).resolves.toBeUndefined();
+        expect(mockSaveLoginCredential).toHaveBeenCalledWith({});
+    });
+    it('throws the API error message for non-401 failures', async () => {
+        mockClientFetch.mockResolvedValue([{ api_error_message: 'boom' }, 500, {}]);
+        await expect(hfetch('/hit/1')).rejects.toThrow('boom');
+    });
+    it('delegates convenience wrappers to hfetch with the expected methods', async () => {
+        mockClientFetch.mockResolvedValue([{ api_response: undefined }, 200, {}]);
+        await hget('/x', new URLSearchParams({ a: '1' }), { Accept: 'json' });
+        await hpost('/x', { ok: true }, { A: '1' }, new URLSearchParams({ b: '2' }));
+        await hput('/x', { ok: true }, { A: '1' }, new URLSearchParams({ b: '2' }));
+        await hpatch('/x', { ok: true }, { A: '1' }, new URLSearchParams({ b: '2' }));
+        await hdelete('/x', { ok: true }, { A: '1' }, new URLSearchParams({ b: '2' }));
+        expect(mockClientFetch).toHaveBeenNthCalledWith(1, '/api/v1//x', 'get', null, new URLSearchParams({ a: '1' }), expect.objectContaining({ Accept: 'json', 'Content-Type': 'application/json' }));
+        expect(mockClientFetch).toHaveBeenNthCalledWith(2, '/api/v1//x', 'post', { ok: true }, new URLSearchParams({ b: '2' }), expect.objectContaining({ A: '1', 'Content-Type': 'application/json' }));
+        expect(mockClientFetch).toHaveBeenNthCalledWith(3, '/api/v1//x', 'put', { ok: true }, new URLSearchParams({ b: '2' }), expect.objectContaining({ A: '1', 'Content-Type': 'application/json' }));
+        expect(mockClientFetch).toHaveBeenNthCalledWith(4, '/api/v1//x', 'patch', { ok: true }, new URLSearchParams({ b: '2' }), expect.objectContaining({ A: '1', 'Content-Type': 'application/json' }));
+        expect(mockClientFetch).toHaveBeenNthCalledWith(5, '/api/v1//x', 'delete', { ok: true }, new URLSearchParams({ b: '2' }), expect.objectContaining({ A: '1', 'Content-Type': 'application/json' }));
+    });
+});

package/api/notebook/environments.test.d.ts

@@ -0,0 +1 @@
+export {};

package/api/notebook/environments.test.js

@@ -0,0 +1,22 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mockHget = vi.hoisted(() => vi.fn());
+const mockJoinUri = vi.hoisted(() => vi.fn((base, part) => `${base}/${part}`));
+vi.mock('api', () => ({
+    hget: mockHget,
+    joinUri: mockJoinUri
+}));
+vi.mock('api/notebook', () => ({
+    uri: () => '/api/v1/notebook'
+}));
+import { get, uri } from './environments';
+describe('notebook environments API', () => {
+    beforeEach(() => {
+        mockHget.mockReset();
+        mockJoinUri.mockClear();
+    });
+    it('builds the environments URI and performs the GET request', async () => {
+        expect(uri()).toBe('/api/v1/notebook/environments');
+        await get();
+        expect(mockHget).toHaveBeenCalledWith('/api/v1/notebook/environments');
+    });
+});

package/api/notebook/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/api/notebook/index.test.js

@@ -0,0 +1,28 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mockHpost = vi.hoisted(() => vi.fn());
+const mockJoinUri = vi.hoisted(() => vi.fn((base, part) => `${base}/${part}`));
+vi.mock('api', () => ({
+    hpost: mockHpost,
+    joinUri: mockJoinUri,
+    uri: () => '/api/v1'
+}));
+vi.mock('api/notebook/environments', () => ({
+    sentinel: 'environments'
+}));
+import { environments, post, uri } from './index';
+describe('notebook API', () => {
+    beforeEach(() => {
+        mockHpost.mockReset();
+        mockJoinUri.mockClear();
+    });
+    it('builds the notebook URI and posts notebook requests', async () => {
+        await post({ link: 'https://example.com', analytic: { name: 'a' } });
+        expect(uri()).toBe('/api/v1/notebook');
+        expect(mockJoinUri).toHaveBeenCalledWith('/api/v1', 'notebook');
+        expect(mockHpost).toHaveBeenCalledWith('/api/v1/notebook/notebook', {
+            link: 'https://example.com',
+            analytic: { name: 'a' }
+        });
+        expect(environments).toEqual({ sentinel: 'environments' });
+    });
+});

package/api/overview/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/api/overview/index.test.js

@@ -0,0 +1,42 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mockHdelete = vi.hoisted(() => vi.fn());
+const mockHget = vi.hoisted(() => vi.fn());
+const mockHpost = vi.hoisted(() => vi.fn());
+const mockHput = vi.hoisted(() => vi.fn());
+const mockJoinAllUri = vi.hoisted(() => vi.fn((...parts) => parts.join('/').replace(/\/+/g, '/')));
+const mockJoinUri = vi.hoisted(() => vi.fn(() => '/api/v1/overview'));
+vi.mock('api', () => ({
+    hdelete: mockHdelete,
+    hget: mockHget,
+    hpost: mockHpost,
+    hput: mockHput,
+    joinAllUri: mockJoinAllUri,
+    joinUri: mockJoinUri,
+    uri: () => '/api/v1'
+}));
+import { del, get, post, put, uri } from './index';
+describe('overview API', () => {
+    beforeEach(() => {
+        mockHdelete.mockReset();
+        mockHget.mockReset();
+        mockHpost.mockReset();
+        mockHput.mockReset();
+        mockJoinAllUri.mockClear();
+        mockJoinUri.mockClear();
+    });
+    it('builds collection and detail overview URIs', () => {
+        expect(uri()).toBe('/api/v1/overview');
+        expect(uri('overview-1')).toBe('/api/v1/overview/overview-1');
+    });
+    it('gets, creates, updates, and deletes overviews', async () => {
+        const refresh = new URLSearchParams({ refresh: 'true' });
+        await get();
+        await post({ content: 'new' }, 'true');
+        await put('overview-1', 'markdown', 'true');
+        await del('overview-1', 'true');
+        expect(mockHget).toHaveBeenCalledWith('/api/v1/overview');
+        expect(mockHpost).toHaveBeenCalledWith('/api/v1/overview', { content: 'new' }, undefined, refresh);
+        expect(mockHput).toHaveBeenCalledWith('/api/v1/overview/overview-1', { content: 'markdown' }, undefined, refresh);
+        expect(mockHdelete).toHaveBeenCalledWith('/api/v1/overview/overview-1', undefined, undefined, refresh);
+    });
+});

package/api/search/fields/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/api/search/fields/index.test.js

@@ -0,0 +1,31 @@
+/// <reference types="vitest" />
+import { describe, expect, it, vi } from 'vitest';
+vi.mock('api', () => ({
+    joinUri: (...parts) => parts.join('/')
+}));
+vi.mock('api/search', () => ({
+    uri: () => '/api/v1/search'
+}));
+vi.mock('api/search/fields/hit', () => ({ token: 'hit' }));
+vi.mock('api/search/fields/user', () => ({ token: 'user' }));
+import * as fields from './index';
+describe('api/search/fields', () => {
+    it('builds the fields URI', () => {
+        expect(fields.uri()).toBe('/api/v1/search/fields');
+    });
+    it('maps field objects and filters indexed fields', () => {
+        const input = {
+            alpha: { default: true, indexed: true, list: false, stored: true, type: 'keyword', description: 'A' },
+            beta: { default: false, indexed: false, list: true, stored: false, type: 'text', description: 'B' }
+        };
+        expect(fields.map(input)).toEqual([
+            { key: 'alpha', default: true, indexed: true, list: false, stored: true, type: 'keyword', description: 'A' },
+            { key: 'beta', default: false, indexed: false, list: true, stored: false, type: 'text', description: 'B' }
+        ]);
+        expect(fields.indexed(input)).toEqual([
+            { key: 'alpha', default: true, indexed: true, list: false, stored: true, type: 'keyword', description: 'A' }
+        ]);
+        expect(fields.hit).toEqual({ token: 'hit' });
+        expect(fields.user).toEqual({ token: 'user' });
+    });
+});

package/api/search/grouped/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/api/search/grouped/index.test.js

@@ -0,0 +1,18 @@
+/// <reference types="vitest" />
+import { describe, expect, it, vi } from 'vitest';
+vi.mock('api', () => ({
+    joinUri: (...parts) => parts.join('/')
+}));
+vi.mock('api/search', () => ({
+    uri: () => '/api/v1/search'
+}));
+vi.mock('api/search/grouped/hit', () => ({ kind: 'hit' }));
+vi.mock('api/search/grouped/user', () => ({ kind: 'user' }));
+import * as grouped from './index';
+describe('api/search/grouped', () => {
+    it('builds the grouped URI and re-exports grouped helpers', () => {
+        expect(grouped.uri()).toBe('/api/v1/search/grouped');
+        expect(grouped.hit).toEqual({ kind: 'hit' });
+        expect(grouped.user).toEqual({ kind: 'user' });
+    });
+});

package/api/search/grouped/user.test.d.ts

@@ -0,0 +1 @@
+export {};

package/api/search/grouped/user.test.js

@@ -0,0 +1,33 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mockHpost = vi.hoisted(() => vi.fn());
+const mockJoinAllUri = vi.hoisted(() => vi.fn((...parts) => parts.join('/').replace(/\/+/g, '/')));
+vi.mock('api', () => ({
+    hpost: mockHpost,
+    joinAllUri: mockJoinAllUri
+}));
+vi.mock('api/search/grouped', () => ({
+    uri: () => '/api/v1/search/grouped'
+}));
+import { post, uri } from './user';
+describe('grouped user search API', () => {
+    beforeEach(() => {
+        mockHpost.mockReset();
+        mockJoinAllUri.mockClear();
+    });
+    it('builds grouped user URIs, applies a default query, and maps uname to username', async () => {
+        mockHpost.mockResolvedValueOnce({
+            items: [{ items: [{ uname: 'alice', display_name: 'Alice' }] }],
+            total: 1
+        });
+        expect(uri('owner')).toBe('/api/v1/search/grouped/user/owner');
+        await expect(post('owner')).resolves.toEqual({
+            items: [{ items: [{ uname: 'alice', display_name: 'Alice', username: 'alice' }] }],
+            total: 1
+        });
+        expect(mockHpost).toHaveBeenCalledWith('/api/v1/search/grouped/user/owner', { query: 'uname:*' });
+    });
+    it('throws when the grouped response is empty', async () => {
+        mockHpost.mockResolvedValueOnce(undefined);
+        await expect(post('owner', { query: 'uname:alice' })).rejects.toThrow('Grouped search response was empty.');
+    });
+});

package/api/search/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/api/search/index.test.js

@@ -0,0 +1,41 @@
+import { describe, expect, it, vi } from 'vitest';
+const mockJoinUri = vi.hoisted(() => vi.fn(() => '/api/v1/search'));
+vi.mock('api', () => ({
+    joinUri: mockJoinUri,
+    uri: () => '/api/v1'
+}));
+vi.mock('api/search/action', () => ({ sentinel: 'action' }));
+vi.mock('api/search/analytic', () => ({ sentinel: 'analytic' }));
+vi.mock('api/search/case', () => ({ sentinel: 'case' }));
+vi.mock('api/search/count', () => ({ sentinel: 'count' }));
+vi.mock('api/search/dossier', () => ({ sentinel: 'dossier' }));
+vi.mock('api/search/facet', () => ({ sentinel: 'facet' }));
+vi.mock('api/search/fields', () => ({ sentinel: 'fields' }));
+vi.mock('api/search/grouped', () => ({ sentinel: 'grouped' }));
+vi.mock('api/search/histogram', () => ({ sentinel: 'histogram' }));
+vi.mock('api/search/hit', () => ({ sentinel: 'hit' }));
+vi.mock('api/search/overview', () => ({ sentinel: 'overview' }));
+vi.mock('api/search/template', () => ({ sentinel: 'template' }));
+vi.mock('api/search/user', () => ({ sentinel: 'user' }));
+vi.mock('api/search/view', () => ({ sentinel: 'view' }));
+import { action, analytic, case as caseApi, count, dossier, facet, fields, grouped, histogram, hit, overview, template, uri, user, view } from './index';
+describe('search API', () => {
+    it('builds the search URI and re-exports nested search modules', () => {
+        expect(uri()).toBe('/api/v1/search');
+        expect(mockJoinUri).toHaveBeenCalledWith('/api/v1', 'search');
+        expect(action).toEqual({ sentinel: 'action' });
+        expect(analytic).toEqual({ sentinel: 'analytic' });
+        expect(caseApi).toEqual({ sentinel: 'case' });
+        expect(count).toEqual({ sentinel: 'count' });
+        expect(dossier).toEqual({ sentinel: 'dossier' });
+        expect(facet).toEqual({ sentinel: 'facet' });
+        expect(fields).toEqual({ sentinel: 'fields' });
+        expect(grouped).toEqual({ sentinel: 'grouped' });
+        expect(histogram).toEqual({ sentinel: 'histogram' });
+        expect(hit).toEqual({ sentinel: 'hit' });
+        expect(overview).toEqual({ sentinel: 'overview' });
+        expect(template).toEqual({ sentinel: 'template' });
+        expect(user).toEqual({ sentinel: 'user' });
+        expect(view).toEqual({ sentinel: 'view' });
+    });
+});

package/api/search/user.test.d.ts

@@ -0,0 +1 @@
+export {};