@intellegens/cornerstone-client 0.0.9999-alpha-30 → 0.0.9999-alpha-32

package/tests/ApiClients.test.ts

@@ -1,284 +0,0 @@
-import { ApiReadControllerClient, ApiCrudControllerClient, UserManagementControllerClient, IHttpService, HttpResponse } from '../src';
-import { jest } from '@jest/globals';
-import { ReadSelectedLogicalOperator } from '../src/data';
-
-// Mock HTTP Service for testing
-class MockHttpService implements IHttpService {
-  private mockResponses = new Map<string, HttpResponse>();
-  public requestLog: Array<{ url: string; config?: any }> = [];
-
-  setMockResponse(url: string, response: HttpResponse) {
-    this.mockResponses.set(url, response);
-  }
-
-  clearMockResponses() {
-    this.mockResponses.clear();
-    this.requestLog = [];
-  }
-
-  async request<T = any>(url: string, config?: any): Promise<HttpResponse<T>> {
-    this.requestLog.push({ url, config });
-
-    const mockResponse = this.mockResponses.get(url);
-    if (mockResponse) {
-      return mockResponse as HttpResponse<T>;
-    }
-
-    // Default successful response
-    return {
-      ok: true,
-      status: 200,
-      statusText: 'OK',
-      headers: {},
-      json: async () => ({ success: true }) as T,
-      text: async () => '{"success":true}',
-    };
-  }
-}
-
-// Mock API Initialization Service
-jest.unstable_mockModule('../src/services/api/ApiInitializationService/index', () => ({
-  apiInitializationService: {
-    getApiUrl: jest.fn((...paths: string[]) => Promise.resolve(`https://api.example.com${paths.join('')}`)),
-  },
-}));
-
-describe('API Clients with HTTP Service Abstraction', () => {
-  let mockHttpService: MockHttpService;
-
-  beforeEach(() => {
-    mockHttpService = new MockHttpService();
-    jest.clearAllMocks();
-  });
-
-  describe('ApiReadControllerClient', () => {
-    let client: ApiReadControllerClient<number, any, any>;
-
-    beforeEach(() => {
-      client = new ApiReadControllerClient('/api/test', mockHttpService);
-    });
-
-    it('should use injected HTTP service for readAll', async () => {
-      const mockData = [
-        { id: 1, name: 'Test' },
-        { id: 2, name: 'Test2' },
-      ];
-      mockHttpService.setMockResponse('https://api.example.com/api/test/ReadAll', {
-        ok: true,
-        status: 200,
-        statusText: 'OK',
-        headers: {},
-        json: async () => ({ success: true, result: mockData, metadata: {} }),
-        text: async () => JSON.stringify({ result: mockData, metadata: {} }),
-      });
-
-      const result = await client.readAll();
-
-      expect(result).toEqual({ result: mockData, metadata: {} });
-      expect(mockHttpService.requestLog.length).toBe(1);
-      expect(mockHttpService.requestLog[0].url).toBe('https://api.example.com/api/test/ReadAll');
-      expect(mockHttpService.requestLog[0].config?.method).toBe('GET');
-    });
-
-    it('should use injected HTTP service for readSingle', async () => {
-      const mockData = { id: 1, name: 'Test' };
-      mockHttpService.setMockResponse('https://api.example.com/api/test/ReadSingle?id=1', {
-        ok: true,
-        status: 200,
-        statusText: 'OK',
-        headers: {},
-        json: async () => ({ success: true, result: mockData, metadata: {} }),
-        text: async () => JSON.stringify({ result: mockData, metadata: {} }),
-      });
-
-      const result = await client.readSingle(1);
-
-      expect(result).toEqual({ result: mockData, metadata: {} });
-      expect(mockHttpService.requestLog.length).toBe(1);
-      expect(mockHttpService.requestLog[0].url).toBe('https://api.example.com/api/test/ReadSingle?id=1');
-    });
-
-    it('should use injected HTTP service for readSelected', async () => {
-      const mockData = [{ id: 1, name: 'Test' }];
-      const definition = {
-        searchDefinition: {
-          searches: [],
-          logicalOperator: ReadSelectedLogicalOperator.And,
-        },
-      };
-
-      mockHttpService.setMockResponse('https://api.example.com/api/test/ReadSelected', {
-        ok: true,
-        status: 200,
-        statusText: 'OK',
-        headers: {},
-        json: async () => ({ success: true, result: mockData, metadata: {} }),
-        text: async () => JSON.stringify({ result: mockData, metadata: {} }),
-      });
-
-      const result = await client.readSelected(definition);
-
-      expect(result).toEqual({ result: mockData, metadata: {} });
-      expect(mockHttpService.requestLog.length).toBe(1);
-      expect(mockHttpService.requestLog[0].url).toBe('https://api.example.com/api/test/ReadSelected');
-      expect(mockHttpService.requestLog[0].config?.method).toBe('POST');
-      expect(mockHttpService.requestLog[0].config?.body).toBe(JSON.stringify(definition));
-    });
-
-    it('should handle HTTP errors properly', async () => {
-      mockHttpService.setMockResponse('https://api.example.com/api/test/ReadAll', {
-        ok: false,
-        status: 500,
-        statusText: 'Internal Server Error',
-        headers: {},
-        json: async () => ({ error: 'Server error' }),
-        text: async () => '{"error":"Server error"}',
-      });
-
-      try {
-        await client.readAll();
-        fail('Should have thrown an error');
-      } catch (error: any) {
-        expect(error.message).toContain('Unknown error fetching all records');
-      }
-    });
-  });
-
-  describe('ApiCrudControllerClient', () => {
-    let client: ApiCrudControllerClient<number, any, any, any, any>;
-
-    beforeEach(() => {
-      client = new ApiCrudControllerClient('/api/crud', mockHttpService);
-    });
-
-    it('should use injected HTTP service for create', async () => {
-      const newItem = { id: 0, name: 'New Item' };
-      const createdItem = { id: 1, name: 'New Item' };
-
-      mockHttpService.setMockResponse('https://api.example.com/api/crud/Create', {
-        ok: true,
-        status: 201,
-        statusText: 'Created',
-        headers: {},
-        json: async () => ({ success: true, result: createdItem, metadata: {} }),
-        text: async () => JSON.stringify({ result: createdItem, metadata: {} }),
-      });
-
-      const result = await client.create(newItem);
-
-      expect(result).toEqual({ result: createdItem, metadata: {} });
-      expect(mockHttpService.requestLog.length).toBe(1);
-      expect(mockHttpService.requestLog[0].url).toBe('https://api.example.com/api/crud/Create');
-      expect(mockHttpService.requestLog[0].config?.method).toBe('POST');
-      expect(mockHttpService.requestLog[0].config?.body).toBe(JSON.stringify(newItem));
-    });
-
-    it('should use injected HTTP service for update', async () => {
-      const updateItem = { id: 1, name: 'Updated Item' };
-
-      mockHttpService.setMockResponse('https://api.example.com/api/crud/Update?id=1', {
-        ok: true,
-        status: 200,
-        statusText: 'OK',
-        headers: {},
-        json: async () => ({ success: true, result: updateItem, metadata: {} }),
-        text: async () => JSON.stringify({ result: updateItem, metadata: {} }),
-      });
-
-      const result = await client.update(1, updateItem);
-
-      expect(result).toEqual({ result: updateItem, metadata: {} });
-      expect(mockHttpService.requestLog.length).toBe(1);
-      expect(mockHttpService.requestLog[0].url).toBe('https://api.example.com/api/crud/Update?id=1');
-      expect(mockHttpService.requestLog[0].config?.method).toBe('PUT');
-    });
-
-    it('should use injected HTTP service for delete', async () => {
-      mockHttpService.setMockResponse('https://api.example.com/api/crud/Delete?id=1', {
-        ok: true,
-        status: 204,
-        statusText: 'No Content',
-        headers: {},
-        json: async () => ({}),
-        text: async () => '',
-      });
-
-      await client.delete(1);
-
-      expect(mockHttpService.requestLog.length).toBe(1);
-      expect(mockHttpService.requestLog[0].url).toBe('https://api.example.com/api/crud/Delete?id=1');
-      expect(mockHttpService.requestLog[0].config?.method).toBe('DELETE');
-    });
-  });
-
-  describe('UserManagementControllerClient', () => {
-    let client: UserManagementControllerClient<number, any, any, any, any>;
-
-    beforeEach(() => {
-      client = new UserManagementControllerClient('/api/users', mockHttpService);
-    });
-
-    it('should use injected HTTP service for getUserRoles', async () => {
-      const mockRoles = ['admin', 'user'];
-
-      mockHttpService.setMockResponse('https://api.example.com/api/users/GetUserRoles/1', {
-        ok: true,
-        status: 200,
-        statusText: 'OK',
-        headers: {},
-        json: async () => ({ success: true, result: mockRoles, metadata: {} }),
-        text: async () => JSON.stringify({ result: mockRoles, metadata: {} }),
-      });
-
-      const result = await client.getUserRoles(1);
-
-      expect(result).toEqual({ result: mockRoles, metadata: {} });
-      expect(mockHttpService.requestLog.length).toBe(1);
-      expect(mockHttpService.requestLog[0].url).toBe('https://api.example.com/api/users/GetUserRoles/1');
-      expect(mockHttpService.requestLog[0].config?.method).toBe('GET');
-    });
-
-    it('should use injected HTTP service for getUserClaims', async () => {
-      const mockClaims = [
-        { type: 'role', value: 'admin' },
-        { type: 'department', value: 'IT' },
-      ];
-
-      mockHttpService.setMockResponse('https://api.example.com/api/users/GetUserClaims/1', {
-        ok: true,
-        status: 200,
-        statusText: 'OK',
-        headers: {},
-        json: async () => ({ success: true, result: mockClaims, metadata: {} }),
-        text: async () => JSON.stringify({ result: mockClaims, metadata: {} }),
-      });
-
-      const result = await client.getUserClaims(1);
-
-      expect(result).toEqual({ result: mockClaims, metadata: {} });
-      expect(mockHttpService.requestLog.length).toBe(1);
-      expect(mockHttpService.requestLog[0].url).toBe('https://api.example.com/api/users/GetUserClaims/1');
-      expect(mockHttpService.requestLog[0].config?.method).toBe('GET');
-    });
-
-    it('should use injected HTTP service for getAllRoles', async () => {
-      const mockRoles = ['admin', 'user', 'moderator'];
-
-      mockHttpService.setMockResponse('https://api.example.com/api/users/GetAllRoles', {
-        ok: true,
-        status: 200,
-        statusText: 'OK',
-        headers: {},
-        json: async () => ({ success: true, result: mockRoles, metadata: {} }),
-        text: async () => JSON.stringify({ result: mockRoles, metadata: {} }),
-      });
-
-      const result = await client.getAllRoles();
-
-      expect(result).toEqual({ result: mockRoles, metadata: {} });
-      expect(mockHttpService.requestLog.length).toBe(1);
-      expect(mockHttpService.requestLog[0].url).toBe('https://api.example.com/api/users/GetAllRoles');
-      expect(mockHttpService.requestLog[0].config?.method).toBe('GET');
-    });
-  });
-});

package/tests/CollectionViewAdapter.test.ts

@@ -1,392 +0,0 @@
-const mockReadSelectedAsync = jest.fn<(definition: unknown) => Promise<unknown>>();
-
-jest.mock('@services', () => {
-  return {
-    ApiReadControllerClient: jest.fn().mockImplementation(() => ({
-      readSelectedAsync: mockReadSelectedAsync,
-    })),
-  };
-});
-
-jest.mock('@intellegens/cornerstone-client', () => {
-  return {
-    ReadSelectedOrderingDirection: {
-      Ascending: 'Ascending',
-      Descending: 'Descending',
-    },
-    ReadSelectedLogicalOperator: {
-      And: 'And',
-      Or: 'Or',
-    },
-    ReadSelectedComparisonOperator: {
-      Contains: 'Contains',
-      Equal: 'Equal',
-      GreaterOrEqual: 'GreaterOrEqual',
-      LessOrEqual: 'LessOrEqual',
-    },
-    ReadSelectedPropertyType: {
-      String: 'String',
-      Int: 'Int',
-      DateTimeOffset: 'DateTimeOffset',
-    },
-  };
-});
-
-import { jest, expect, describe, test, beforeEach, afterEach } from '@jest/globals';
-import { ReadSelectedComparisonOperator, ReadSelectedLogicalOperator, ReadSelectedOrderingDirection, ReadSelectedPropertyType } from '../src/data';
-import { CollectionViewAdapter, CollectionViewAdapterOptions } from '../src/adapters';
-import { dateInterval, searchTerm } from '../src/utils';
-
-type TestDto = { id: number; name: string; createdAt: string; rowVersion: string };
-
-const makeItems = (n: number): TestDto[] =>
-  Array.from({ length: n }, (_, i) => ({
-    id: i + 1,
-    name: `Item ${i + 1}`,
-    createdAt: new Date(2024, 0, i + 1).toISOString(),
-    rowVersion: '1',
-  }));
-
-const fetchData = async () => {
-  // _fetchCurrentPageData() in CollectionViewAdapter has 50ms timeout set
-  jest.advanceTimersByTime(60);
-  // allow any pending microtasks to resolve
-  await Promise.resolve();
-};
-
-describe('CollectionViewAdapter', () => {
-  beforeEach(() => {
-    jest.useFakeTimers();
-    mockReadSelectedAsync.mockReset();
-  });
-
-  afterEach(() => {
-    jest.useRealTimers();
-  });
-
-  // overrides?: Partial for passing options properties from test:
-  // const { adapter, callback } = setup({ useTotalItemCount: true });
-  const setup = (overrides?: Partial<CollectionViewAdapterOptions<TestDto>>) => {
-    const options: CollectionViewAdapterOptions<TestDto> = {
-      pagination: {
-        useTotalItemCount: true,
-        pageSize: 10,
-        pageNumber: 1,
-        ...overrides?.pagination,
-      },
-      ordering: {
-        maxActiveOrderingColumns: 1,
-        orderByPaths: [],
-        ...overrides?.ordering,
-      },
-      search: {
-        textSearchableProperties: ['name'],
-        numericSearchableProperties: ['id'],
-        ...overrides?.search,
-      },
-    };
-
-    const callback = jest.fn();
-    const adapter = new CollectionViewAdapter<number, TestDto, TestDto>('ControllerName', callback, options);
-
-    return { adapter, callback };
-  };
-
-  test('callback returns correct loading status and collection data', async () => {
-    const data = makeItems(10);
-    mockReadSelectedAsync.mockResolvedValueOnce({ result: data, metadata: { totalCount: 123 } });
-
-    const { adapter, callback } = setup({ pagination: { useTotalItemCount: true } });
-
-    await fetchData();
-
-    expect(callback).toHaveBeenNthCalledWith(1, true, []);
-    expect(callback).toHaveBeenLastCalledWith(false, data);
-    expect(adapter.totalItemCount).toBe(123);
-  });
-
-  test('adapter options set correct ordering', async () => {
-    mockReadSelectedAsync.mockResolvedValue({ result: makeItems(3), metadata: {} });
-
-    const { adapter } = setup();
-    const promise = adapter.setOrdering(['name'], ReadSelectedOrderingDirection.Descending);
-
-    await fetchData();
-    await promise;
-
-    expect(mockReadSelectedAsync).toHaveBeenLastCalledWith(
-      expect.objectContaining({
-        orderingDefinition: {
-          order: [
-            {
-              propertyPath: ['Name'], // PascalCased
-              direction: ReadSelectedOrderingDirection.Descending,
-            },
-          ],
-        },
-      }),
-      undefined, // The abort signal parameter
-    );
-
-    expect(adapter.getCurrentOrdering()).toEqual({
-      orderByPath: ['name'],
-      orderDirection: ReadSelectedOrderingDirection.Descending,
-    });
-  });
-
-  test('text search is applied to adapter', async () => {
-    mockReadSelectedAsync.mockResolvedValue({ result: makeItems(1), metadata: {} });
-
-    const { adapter } = setup({ search: { textSearchableProperties: ['name'] } });
-
-    const searchDefinition = searchTerm('Waldo', ['name'], ['id']);
-    if (!searchDefinition) throw new Error('searchDefinition is undefined');
-    const promise = adapter.setSearchDefinition(searchDefinition);
-    await fetchData();
-    await promise;
-
-    expect(mockReadSelectedAsync).toHaveBeenLastCalledWith(
-      expect.objectContaining({
-        searchDefinition: expect.objectContaining({
-          logicalOperator: expect.any(Number),
-          propertyCriteria: expect.arrayContaining([
-            expect.objectContaining({
-              propertyPath: 'Name',
-              comparisonOperator: ReadSelectedComparisonOperator.Contains,
-              valueType: ReadSelectedPropertyType.String,
-              value: 'Waldo',
-            }),
-          ]),
-        }),
-      }),
-      undefined, // The abort signal parameter
-    );
-  });
-
-  test('numeric search is applied to adapter', async () => {
-    mockReadSelectedAsync.mockResolvedValue({ result: makeItems(1), metadata: {} });
-
-    const { adapter } = setup({ search: { textSearchableProperties: ['id'] } });
-
-    const searchDefinition = searchTerm('42', ['name'], ['id']);
-    if (!searchDefinition) throw new Error('searchDefinition is undefined');
-    const promise = adapter.setSearchDefinition(searchDefinition);
-    await fetchData();
-    await promise;
-
-    expect(mockReadSelectedAsync).toHaveBeenLastCalledWith(
-      expect.objectContaining({
-        searchDefinition: expect.objectContaining({
-          logicalOperator: expect.any(Number),
-          propertyCriteria: expect.arrayContaining([
-            expect.objectContaining({
-              propertyPath: ['Id'],
-              comparisonOperator: ReadSelectedComparisonOperator.Equal,
-              valueType: ReadSelectedPropertyType.Int,
-              value: 42,
-            }),
-          ]),
-        }),
-      }),
-      undefined,
-    );
-  });
-
-  test('applies date range filter from-to on the same date type property', async () => {
-    mockReadSelectedAsync.mockResolvedValue({ result: makeItems(1), metadata: {} });
-
-    const { adapter } = setup();
-    const from = new Date('2024-01-05T00:00:00.000Z');
-    const to = new Date('2024-01-20T00:00:00.000Z');
-
-    const searchDefinition = dateInterval<TestDto>(
-      from,
-      to,
-      ReadSelectedComparisonOperator.GreaterOrEqual,
-      ReadSelectedComparisonOperator.LessOrEqual,
-      ReadSelectedPropertyType.DateTimeOffset,
-      'createdAt',
-    );
-    if (!searchDefinition) throw new Error('searchDefinition is undefined');
-    const promise = adapter.setSearchDefinition(searchDefinition);
-    await fetchData();
-    await promise;
-
-    expect(mockReadSelectedAsync).toHaveBeenLastCalledWith(
-      expect.objectContaining({
-        searchDefinition: expect.objectContaining({
-          logicalOperator: ReadSelectedLogicalOperator.And,
-          propertyCriteria: expect.arrayContaining([
-            expect.objectContaining({
-              propertyPath: ['DateProperty'],
-              comparisonOperator: ReadSelectedComparisonOperator.GreaterOrEqual,
-              valueType: ReadSelectedPropertyType.DateTimeOffset,
-              value: expect.any(Object),
-            }),
-            expect.objectContaining({
-              propertyPath: ['DateProperty'],
-              comparisonOperator: ReadSelectedComparisonOperator.LessOrEqual,
-              valueType: ReadSelectedPropertyType.DateTimeOffset,
-              value: expect.any(Object),
-            }),
-          ]),
-        }),
-      }),
-      undefined, // The abort signal parameter
-    );
-  });
-
-  test('applies pagination: page size and jump to page set skip/limit', async () => {
-    mockReadSelectedAsync.mockResolvedValue({ result: makeItems(5), metadata: {} });
-
-    const { adapter } = setup({ pagination: { useTotalItemCount: true, pageSize: 5, pageNumber: 1 } });
-
-    const promise = adapter.jumpToPage(3);
-    await fetchData();
-    await promise;
-
-    expect(mockReadSelectedAsync).toHaveBeenLastCalledWith(
-      // ReadSelectedDefinitionDto
-      expect.objectContaining({
-        paginationDefinition: { skip: 10, limit: 5 },
-        searchDefinition: undefined,
-      }),
-      undefined, // The abort signal parameter
-    );
-  });
-
-  test('calculates total when useTotalItemCount=false and last page is partial', async () => {
-    mockReadSelectedAsync.mockResolvedValue({ result: makeItems(3), metadata: {} });
-
-    const { adapter } = setup({ pagination: { useTotalItemCount: false, pageSize: 5, pageNumber: 2 } });
-
-    await fetchData();
-
-    expect(adapter.totalItemCount).toBe(8); // 3 items on page 2 (5 skipped on first page) ... 5+3=8
-  });
-
-  test('setOrdering correctly handles PropertyPathDto array comparison and limits columns', async () => {
-    mockReadSelectedAsync.mockResolvedValue({ result: makeItems(3), metadata: {} });
-
-    const { adapter } = setup({ ordering: { maxActiveOrderingColumns: 2, orderByPaths: [] } });
-
-    // Add first ordering
-    let promise = adapter.setOrdering(['name'], ReadSelectedOrderingDirection.Descending);
-    await fetchData();
-    await promise;
-
-    expect(adapter.getCurrentOrdering()).toEqual({
-      orderByPath: ['name'],
-      orderDirection: ReadSelectedOrderingDirection.Descending,
-    });
-
-    // Add second ordering
-    promise = adapter.setOrdering(['id'], ReadSelectedOrderingDirection.Ascending);
-    await fetchData();
-    await promise;
-
-    // Should have both orderings, with 'id' first (most recent)
-    expect(mockReadSelectedAsync).toHaveBeenLastCalledWith(
-      expect.objectContaining({
-        orderingDefinition: {
-          order: [
-            {
-              propertyPath: ['Id'], // PascalCased
-              direction: ReadSelectedOrderingDirection.Ascending,
-            },
-            {
-              propertyPath: ['Name'], // PascalCased
-              direction: ReadSelectedOrderingDirection.Descending,
-            },
-          ],
-        },
-      }),
-      undefined,
-    );
-
-    // Add third ordering - should remove the oldest one (name)
-    promise = adapter.setOrdering(['createdAt'], ReadSelectedOrderingDirection.Descending);
-    await fetchData();
-    await promise;
-
-    expect(mockReadSelectedAsync).toHaveBeenLastCalledWith(
-      expect.objectContaining({
-        orderingDefinition: {
-          order: [
-            {
-              propertyPath: ['CreatedAt'], // PascalCased
-              direction: ReadSelectedOrderingDirection.Descending,
-            },
-            {
-              propertyPath: ['Id'], // PascalCased
-              direction: ReadSelectedOrderingDirection.Ascending,
-            },
-          ],
-        },
-      }),
-      undefined,
-    );
-
-    // Update existing ordering - should replace, not add
-    promise = adapter.setOrdering(['id'], ReadSelectedOrderingDirection.Descending);
-    await fetchData();
-    await promise;
-
-    expect(mockReadSelectedAsync).toHaveBeenLastCalledWith(
-      expect.objectContaining({
-        orderingDefinition: {
-          order: [
-            {
-              propertyPath: ['Id'], // PascalCased - updated direction
-              direction: ReadSelectedOrderingDirection.Descending,
-            },
-            {
-              propertyPath: ['CreatedAt'], // PascalCased
-              direction: ReadSelectedOrderingDirection.Descending,
-            },
-          ],
-        },
-      }),
-      undefined,
-    );
-  });
-
-  test('setOrdering correctly compares complex PropertyPathDto arrays', async () => {
-    mockReadSelectedAsync.mockResolvedValue({ result: makeItems(3), metadata: {} });
-
-    const { adapter } = setup({ ordering: { maxActiveOrderingColumns: 3, orderByPaths: [] } });
-
-    // Add ordering with nested property path
-    let promise = adapter.setOrdering(['user', 'profile', 'name'], ReadSelectedOrderingDirection.Ascending);
-    await fetchData();
-    await promise;
-
-    // Add different nested path
-    promise = adapter.setOrdering(['user', 'settings', 'theme'], ReadSelectedOrderingDirection.Descending);
-    await fetchData();
-    await promise;
-
-    // Update the first nested path - should replace it, not add new
-    promise = adapter.setOrdering(['user', 'profile', 'name'], ReadSelectedOrderingDirection.Descending);
-    await fetchData();
-    await promise;
-
-    expect(mockReadSelectedAsync).toHaveBeenLastCalledWith(
-      expect.objectContaining({
-        orderingDefinition: {
-          order: [
-            {
-              propertyPath: ['User', 'Profile', 'Name'], // PascalCased - updated direction
-              direction: ReadSelectedOrderingDirection.Descending,
-            },
-            {
-              propertyPath: ['User', 'Settings', 'Theme'], // PascalCased
-              direction: ReadSelectedOrderingDirection.Descending,
-            },
-          ],
-        },
-      }),
-      undefined,
-    );
-  });
-});