dataconv-client-sdk-ts 0.2.0 → 0.2.1

package/src/__tests__/DataConvClient.test.ts

@@ -1,608 +0,0 @@
-import axios from 'axios';
-import { DataConvClient } from '../DataConvClient';
-import type {
-  ConvertedBundleResource,
-  DataConvCrypto,
-  DataConvDidCommResponse,
-  TenantAdapterConfigResource
-} from '../types';
-
-jest.mock('axios');
-
-const mockedAxios = axios as jest.Mocked<typeof axios>;
-const UUID_V4_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-const originalFetch = global.fetch;
-
-function createMockResponse(status: number, headers: Headers = new Headers(), data: any = {}) {
-  return {
-    status,
-    headers,
-    json: jest.fn().mockResolvedValue(data),
-    text: jest.fn().mockResolvedValue(JSON.stringify(data)),
-    ok: status >= 200 && status < 300,
-    statusText: '',
-    type: 'basic',
-    url: 'http://localhost:8080',
-    redirected: false,
-    clone: () => ({} as Response),
-    body: null,
-    bodyUsed: false,
-    arrayBuffer: jest.fn().mockResolvedValue(new ArrayBuffer(0)),
-    blob: jest.fn().mockResolvedValue(new Blob([])),
-    formData: jest.fn().mockResolvedValue(new FormData())
-  } as unknown as Response;
-}
-
-describe('DataConvClient', () => {
-  let client: DataConvClient;
-
-  beforeEach(() => {
-    mockedAxios.create.mockReturnValue(mockedAxios);
-    if (!mockedAxios.request) {
-      mockedAxios.request = jest.fn();
-    }
-    mockedAxios.request.mockReset();
-
-    client = new DataConvClient({
-      issuerDid: 'did:web:clinic.example:employee:it:loader',
-      alternateName: 'clinic-demo',
-      tenantId: 'clinic-demo',
-      jurisdiction: 'ES',
-      baseUrl: 'http://localhost:8080',
-      retryTimes: 3,
-      retryDelayMs: 1
-    });
-  });
-
-  afterEach(() => {
-    global.fetch = originalFetch;
-  });
-
-  it('creates tenant config requests', async () => {
-    mockedAxios.request.mockResolvedValueOnce({
-      status: 202,
-      headers: { location: '/host/cds-ES/v1/onehealth-research/clinic-demo/qvet-v1.0/config/_create-response?thid=cfg-1' }
-    });
-
-    const result = await client.createConfig({
-      entries: [
-        {
-          softwareId: 'qvet-v1.0',
-          config: {
-            mappingConfig: {
-              headerRowIndex: 1,
-              fieldMap: { section: 'SECCION', concept: 'CONCEPTO' }
-            }
-          }
-        }
-      ]
-    });
-
-    expect(result.thid).toMatch(UUID_V4_REGEX);
-    expect(result.location).toContain('_create-response');
-    expect(mockedAxios.request).toHaveBeenCalledWith(expect.objectContaining({
-      method: 'POST',
-      url: '/host/cds-ES/v1/onehealth-research/clinic-demo/qvet-v1.0/config/_create',
-      headers: { 'Content-Type': 'application/didcomm-plain+json' },
-      data: expect.objectContaining({
-        iss: 'did:web:clinic.example:employee:it:loader',
-        thid: expect.any(String),
-        jti: expect.any(String),
-        data: [
-          expect.objectContaining({ softwareId: 'qvet-v1.0' })
-        ]
-      })
-    }));
-  });
-
-  it('prefers tenantId over alternateName for tenant config endpoints', async () => {
-    const vatClient = new DataConvClient({
-      issuerDid: 'did:web:clinic.example:employee:it:loader',
-      alternateName: 'clinic-demo',
-      tenantId: 'VATES-B00000000',
-      jurisdiction: 'ES',
-      baseUrl: 'http://localhost:8080',
-      retryTimes: 3,
-      retryDelayMs: 1
-    });
-
-    mockedAxios.request.mockResolvedValueOnce({
-      status: 202,
-      headers: { location: '/host/cds-ES/v1/onehealth-research/VATES-B00000000/qvet-v1.0/config/_create-response?thid=cfg-1' }
-    });
-
-    await vatClient.createConfig({
-      entries: [{ softwareId: 'qvet-v1.0' }]
-    });
-
-    expect(mockedAxios.request).toHaveBeenCalledWith(expect.objectContaining({
-      url: '/host/cds-ES/v1/onehealth-research/VATES-B00000000/qvet-v1.0/config/_create'
-    }));
-  });
-
-  it('polls tenant config responses and stores successful resources', async () => {
-    const payload: DataConvDidCommResponse<TenantAdapterConfigResource> = {
-      thid: 'cfg-1',
-      iss: 'did:web:globaldatacare.es:employee:preconversion',
-      aud: 'did:web:clinic.example:employee:it:loader',
-      type: 'https://didcomm.org/plaintext/2.0/message',
-      iat: 1760000000,
-      exp: 1760000300,
-      body: {
-        resourceType: 'Bundle',
-        type: 'batch-response',
-        total: 1,
-        data: [
-          {
-            type: 'TenantAdapterConfig',
-            response: { status: '200' },
-            resource: {
-              id: 'cfg-1',
-              type: 'tenant-adapter-config',
-              alternateName: 'clinic-demo',
-              softwareId: 'qvet-v1.0',
-              country: 'ES',
-              facilityId: '',
-              revision: '1',
-              createdAt: '2026-03-12T06:55:50Z',
-              updatedAt: '2026-03-12T07:11:23Z',
-              audit: {},
-              content: {}
-            }
-          }
-        ]
-      }
-    };
-
-    mockedAxios.request
-      .mockResolvedValueOnce({ status: 202, headers: { 'retry-after': '0' } })
-      .mockResolvedValueOnce({ status: 200, headers: {}, data: payload });
-
-    const response = await client.pollConfig({ thid: 'cfg-1', softwareId: 'qvet-v1.0' });
-
-    expect(response).toEqual(payload);
-    expect(client.getLastTenantConfigResponse()).toEqual(payload);
-    expect(client.getSuccessfulTenantConfigs()).toEqual([payload.body?.data?.[0]?.resource]);
-  });
-
-  it('uploads a spreadsheet by link as a DIDComm attachment', async () => {
-    mockedAxios.request.mockResolvedValueOnce({
-      status: 202,
-      headers: { location: '/clinic-demo/cds-ES/v1/onehealth-research/digitaltwin/qvet-v1.0/Composition/_upload-response?thid=up-1' }
-    });
-
-    const result = await client.uploadWithLink('https://example.com/exampleQvetES.xlsx?dl=1', {
-      softwareId: 'qvet-v1.0',
-      fileName: 'exampleQvetES.xlsx'
-    });
-
-    expect(result.thid).toMatch(UUID_V4_REGEX);
-    expect(mockedAxios.request).toHaveBeenCalledWith(expect.objectContaining({
-      method: 'POST',
-      url: '/clinic-demo/cds-ES/v1/onehealth-research/digitaltwin/qvet-v1.0/Composition/_upload',
-      headers: { 'Content-Type': 'application/didcomm-plain+json' },
-      data: expect.objectContaining({
-        sourceFormat: 'excel',
-        attachments: [
-          expect.objectContaining({
-            filename: 'exampleQvetES.xlsx',
-            data: { links: ['https://example.com/exampleQvetES.xlsx?dl=1'] }
-          })
-        ]
-      })
-    }));
-  });
-
-  it('uploads a spreadsheet by base64 and includes tokens', async () => {
-    client.setIdToken('id-token-1');
-    client.setVpToken('vp-token-1');
-    mockedAxios.request.mockResolvedValueOnce({
-      status: 202,
-      headers: { location: '/dummy' }
-    });
-
-    await client.uploadSpreadsheet(new Uint8Array([1, 2, 3]), {
-      softwareId: 'qvet-v1.0',
-      fileName: 'exampleQvetES.xlsx'
-    });
-
-    expect(mockedAxios.request).toHaveBeenCalledWith(expect.objectContaining({
-      data: expect.objectContaining({
-        id_token: 'id-token-1',
-        vp_token: 'vp-token-1',
-        sourceFormat: 'excel',
-        attachments: [
-          expect.objectContaining({
-            data: { base64: Buffer.from([1, 2, 3]).toString('base64') }
-          })
-        ]
-      })
-    }));
-  });
-
-  it('builds multipart upload requests', async () => {
-    mockedAxios.request.mockResolvedValueOnce({
-      status: 202,
-      headers: { location: '/dummy' }
-    });
-
-    await client.uploadWithFile({
-      softwareId: 'qvet-v1.0',
-      fileBytes: new Uint8Array([4, 5, 6]),
-      fileName: 'exampleQvetES.xlsx'
-    });
-
-    const requestConfig = mockedAxios.request.mock.calls[0]?.[0];
-    expect(requestConfig?.url).toBe('/clinic-demo/cds-ES/v1/onehealth-research/digitaltwin/qvet-v1.0/Composition/_upload');
-    expect(requestConfig?.data).toBeInstanceOf(FormData);
-    const payloadEntry = Array.from((requestConfig?.data as FormData).entries()).find(([key]) => key === 'payload');
-    expect(payloadEntry?.[1]).toEqual(expect.any(String));
-    const payloadJson = JSON.parse(String(payloadEntry?.[1]));
-    expect(payloadJson.sourceFormat).toBe('excel');
-  });
-
-  it('polls conversion responses and extracts the converted bundle', async () => {
-    const payload: DataConvDidCommResponse<ConvertedBundleResource> = {
-      thid: 'up-1',
-      iss: 'did:web:globaldatacare.es:employee:preconversion',
-      aud: 'did:web:clinic.example:employee:it:loader',
-      type: 'https://didcomm.org/plaintext/2.0/message',
-      iat: 1760000000,
-      exp: 1760000300,
-      body: {
-        resourceType: 'Bundle',
-        type: 'batch-response',
-        total: 1,
-        data: [
-          {
-            type: 'ConversionResult',
-            response: { status: '200' },
-            resource: {
-              resourceType: 'Bundle',
-              type: 'batch',
-              total: 1,
-              data: [{ resource: { resourceType: 'Patient', id: 'patient-1' } }]
-            }
-          }
-        ]
-      }
-    };
-
-    mockedAxios.request
-      .mockResolvedValueOnce({ status: 202, headers: { 'retry-after': '0' } })
-      .mockResolvedValueOnce({ status: 200, headers: {}, data: payload });
-
-    const response = await client.pollUploadResponse({
-      thid: 'up-1',
-      softwareId: 'qvet-v1.0'
-    });
-
-    expect(response).toEqual(payload);
-    expect(client.getLastConversionResponse()).toEqual(payload);
-    expect(client.getConversionEntry()?.response?.status).toBe('200');
-    expect(client.getConvertedBundle()).toEqual(payload.body?.data?.[0]?.resource);
-  });
-
-  it('uses injected crypto for generated thread ids', async () => {
-    const crypto: DataConvCrypto = {
-      randomUUID: jest.fn(() => '11111111-2222-4333-8444-555555555555')
-    };
-    const injectedClient = new DataConvClient({
-      issuerDid: 'did:web:clinic.example:employee:it:loader',
-      alternateName: 'clinic-demo',
-      tenantId: 'clinic-demo',
-      jurisdiction: 'ES',
-      crypto
-    });
-
-    mockedAxios.request.mockResolvedValueOnce({
-      status: 202,
-      headers: { location: '/dummy' }
-    });
-
-    const result = await injectedClient.createConfig({
-      entries: [{ softwareId: 'qvet-v1.0' }]
-    });
-
-    expect(result.thid).toBe('11111111-2222-4333-8444-555555555555');
-    expect(crypto.randomUUID).toHaveBeenCalledTimes(1);
-  });
-
-  it('uploads a spreadsheet using fetch when axios is not injected', async () => {
-    mockedAxios.create.mockReset();
-    mockedAxios.create.mockReturnValue(undefined as any);
-
-    const mockFetch = jest.fn();
-    global.fetch = mockFetch as typeof fetch;
-
-    const fetchClient = new DataConvClient({
-      issuerDid: 'did:web:clinic.example:employee:it:loader',
-      alternateName: 'clinic-demo',
-      tenantId: 'clinic-demo',
-      jurisdiction: 'ES',
-      baseUrl: 'http://localhost:8080',
-      retryTimes: 2,
-      retryDelayMs: 1,
-      fetch: mockFetch as typeof fetch
-    });
-
-    mockFetch.mockResolvedValue(
-      createMockResponse(202, new Headers({ location: '/clinic-demo/cds-ES/v1/onehealth-research/digitaltwin/qvet-v1.0/Composition/_upload-response?thid=up-1' }), {})
-    );
-
-    const result = await fetchClient.uploadWithLink('https://example.com/exampleQvetES.xlsx?dl=1', {
-      softwareId: 'qvet-v1.0',
-      fileName: 'exampleQvetES.xlsx'
-    });
-
-    expect(result.thid).toMatch(UUID_V4_REGEX);
-    expect(mockFetch).toHaveBeenCalledWith(
-      'http://localhost:8080/clinic-demo/cds-ES/v1/onehealth-research/digitaltwin/qvet-v1.0/Composition/_upload',
-      expect.objectContaining({
-        method: 'POST',
-        headers: { 'Content-Type': 'application/didcomm-plain+json' },
-        body: expect.any(String)
-      })
-    );
-
-    const rawBody = mockFetch.mock.calls[0]?.[1]?.body;
-    const payload = typeof rawBody === 'string' ? JSON.parse(rawBody) : undefined;
-    expect(payload?.iss).toBe('did:web:clinic.example:employee:it:loader');
-    expect(payload?.thid).toEqual(expect.any(String));
-    expect(payload?.sourceFormat).toBe('excel');
-    expect(payload?.attachments?.[0]?.data?.links).toEqual(['https://example.com/exampleQvetES.xlsx?dl=1']);
-  });
-
-  it('polls conversion responses using fetch', async () => {
-    mockedAxios.create.mockReset();
-    mockedAxios.create.mockReturnValue(undefined as any);
-
-    const mockFetch = jest.fn();
-    global.fetch = mockFetch as typeof fetch;
-
-    const fetchClient = new DataConvClient({
-      issuerDid: 'did:web:clinic.example:employee:it:loader',
-      alternateName: 'clinic-demo',
-      tenantId: 'clinic-demo',
-      jurisdiction: 'ES',
-      baseUrl: 'http://localhost:8080',
-      retryTimes: 2,
-      retryDelayMs: 1,
-      fetch: mockFetch as typeof fetch
-    });
-
-    mockFetch
-      .mockResolvedValueOnce(createMockResponse(202, new Headers({ 'retry-after': '0' }), {}))
-      .mockResolvedValueOnce(createMockResponse(200, new Headers({ 'content-type': 'application/json' }), {
-        thid: 'up-1',
-        body: { data: [{ type: 'ConversionResult', response: { status: '200' }, resource: { resourceType: 'Bundle' } }] }
-      }));
-
-    const response = await fetchClient.pollUploadResponse({
-      thid: 'up-1',
-      softwareId: 'qvet-v1.0'
-    });
-
-    expect(response.thid).toBe('up-1');
-    expect(mockFetch).toHaveBeenCalledTimes(2);
-    expect(fetchClient.getConversionEntry(response)?.type).toBe('ConversionResult');
-  });
-
-
-  it('patches promoted conversion resources through the canonical digital twin endpoint', async () => {
-    client.setIdToken('session-id-1');
-    client.setVpToken('vp-token-1');
-    mockedAxios.request.mockResolvedValueOnce({
-      status: 200,
-      headers: {},
-      data: {
-        type: 'https://didcomm.org/plaintext/2.0/message',
-        thid: 'up-1',
-        body: { status: 'success', promotedCount: 2 }
-      }
-    });
-
-    const response = await client.patchConversion({
-      thid: 'up-1',
-      softwareId: 'qvet-v1.0'
-    });
-
-    expect(response.body?.status).toBe('success');
-    expect(response.body?.promotedCount).toBe(2);
-    expect(mockedAxios.request).toHaveBeenCalledWith(expect.objectContaining({
-      method: 'POST',
-      url: '/clinic-demo/cds-ES/v1/onehealth-research/digitaltwin/qvet-v1.0/Composition/_patch?thid=up-1',
-      headers: { 'Content-Type': 'application/didcomm-plain+json' },
-      data: expect.objectContaining({
-        id_token: 'session-id-1',
-        vp_token: 'vp-token-1',
-        thid: 'up-1'
-      })
-    }));
-  });
-
-  it('searches research resources with FHIR-like parameters', async () => {
-    client.setIdToken('session-id-1');
-    mockedAxios.request.mockResolvedValueOnce({
-      status: 200,
-      headers: {},
-      data: {
-        resourceType: 'Bundle',
-        type: 'searchset',
-        total: 1,
-        entry: [
-          {
-            resource: {
-              resourceType: 'DocumentReference',
-              id: 'doc-1',
-              meta: {
-                claims: {
-                  'DocumentReference.userSelected': 'false'
-                }
-              }
-            }
-          }
-        ]
-      }
-    });
-
-    const response = await client.searchResources({
-      resourceType: 'DocumentReference',
-      searchParams: {
-        userselected: 'false',
-        date: 'ge2026-01-01'
-      }
-    });
-
-    expect(response.total).toBe(1);
-    expect(mockedAxios.request).toHaveBeenCalledWith(expect.objectContaining({
-      method: 'POST',
-      url: '/host/cds-ES/v1/onehealth-research/clinic-demo/org.hl7.fhir.api/DocumentReference/_search',
-      headers: {
-        'Content-Type': 'application/json',
-        Authorization: 'Bearer session-id-1'
-      },
-      data: {
-        userselected: 'false',
-        date: 'ge2026-01-01'
-      }
-    }));
-  });
-
-  it('normalizes FHIR search parameter names to lowercase before sending the request', async () => {
-    client.setIdToken('session-id-1');
-    mockedAxios.request.mockResolvedValueOnce({
-      status: 200,
-      headers: {},
-      data: {
-        resourceType: 'Bundle',
-        type: 'searchset',
-        total: 0,
-        entry: []
-      }
-    });
-
-    await client.searchResources({
-      resourceType: 'DocumentReference',
-      searchParams: {
-        userSelected: 'false',
-        date: 'ge2026-01-01'
-      }
-    });
-
-    expect(mockedAxios.request).toHaveBeenCalledWith(expect.objectContaining({
-      method: 'POST',
-      url: '/host/cds-ES/v1/onehealth-research/clinic-demo/org.hl7.fhir.api/DocumentReference/_search',
-      headers: {
-        'Content-Type': 'application/json',
-        Authorization: 'Bearer session-id-1'
-      },
-      data: {
-        userselected: 'false',
-        date: 'ge2026-01-01'
-      }
-    }));
-  });
-
-  it('supports a mocked config, upload, poll, batch and search workflow', async () => {
-    mockedAxios.request
-      .mockResolvedValueOnce({
-        status: 202,
-        headers: { location: '/host/cds-ES/v1/onehealth-research/clinic-demo/qvet-v1.0/config/_create-response?thid=cfg-1' }
-      })
-      .mockResolvedValueOnce({ status: 202, headers: { 'retry-after': '0' } })
-      .mockResolvedValueOnce({
-        status: 200,
-        headers: {},
-        data: {
-          thid: 'cfg-1',
-          body: {
-            data: [
-              {
-                type: 'TenantAdapterConfig',
-                response: { status: '200' },
-                resource: { id: 'cfg-1', softwareId: 'qvet-v1.0' }
-              }
-            ]
-          }
-        }
-      })
-      .mockResolvedValueOnce({
-        status: 202,
-        headers: { location: '/clinic-demo/cds-ES/v1/onehealth-research/digitaltwin/qvet-v1.0/Composition/_upload-response?thid=up-1' }
-      })
-      .mockResolvedValueOnce({ status: 202, headers: { 'retry-after': '0' } })
-      .mockResolvedValueOnce({
-        status: 200,
-        headers: {},
-        data: {
-          thid: 'up-1',
-          body: {
-            data: [
-              {
-                type: 'ConversionResult',
-                response: { status: '200' },
-                resource: { resourceType: 'Bundle', total: 1 }
-              }
-            ]
-          }
-        }
-      })
-      .mockResolvedValueOnce({
-        status: 200,
-        headers: {},
-        data: { body: { status: 'success', promotedCount: 2 } }
-      })
-      .mockResolvedValueOnce({
-        status: 200,
-        headers: {},
-        data: {
-          resourceType: 'Bundle',
-          type: 'searchset',
-          total: 1,
-          entry: [{ resource: { resourceType: 'Composition', id: 'comp-1' } }]
-        }
-      });
-
-    const configResponse = await client.createTenantConfigAndWait({
-      softwareId: 'qvet-v1.0',
-      entries: [{ softwareId: 'qvet-v1.0' }]
-    });
-    const uploadResponse = await client.uploadSpreadsheetAndWait('https://example.com/exampleQvetES.xlsx?dl=1', {
-      softwareId: 'qvet-v1.0',
-      fileName: 'exampleQvetES.xlsx'
-    });
-    const patchResponse = await client.batchPromotion({
-      thid: 'up-1',
-      softwareId: 'qvet-v1.0'
-    });
-    const searchResponse = await client.searchResources({
-      resourceType: 'Composition',
-      searchParams: { 'relatesto-target': 'up-1' }
-    });
-
-    expect(configResponse.body?.data?.[0]?.resource?.softwareId).toBe('qvet-v1.0');
-    expect(uploadResponse.thid).toBe('up-1');
-    expect(patchResponse.body?.promotedCount).toBe(2);
-    expect(searchResponse.total).toBe(1);
-  });
-
-  it('throws if neither axios nor fetch transport is available', async () => {
-    mockedAxios.create.mockReset();
-    mockedAxios.create.mockReturnValue(undefined as any);
-    Reflect.set(globalThis as object, 'fetch', undefined);
-
-    const clientNoTransport = new DataConvClient({
-      issuerDid: 'did:web:clinic.example:employee:it:loader',
-      alternateName: 'clinic-demo',
-      tenantId: 'clinic-demo',
-      jurisdiction: 'ES'
-    });
-
-    await expect(clientNoTransport.createConfig({
-      entries: [{ softwareId: 'qvet-v1.0' }]
-    })).rejects.toThrow(
-      'No HTTP transport available: provide axios httpClient or fetch implementation'
-    );
-  });
-});

package/src/client/constants.ts

@@ -1,8 +0,0 @@
-export const DEFAULT_DIDCOMM_TYPE = 'https://didcomm.org/plaintext/2.0/message';
-export const DEFAULT_SECTOR = 'onehealth-research';
-export const DEFAULT_UPLOAD_BODY = {
-  resourceType: 'Bundle',
-  type: 'batch',
-  data: [],
-  total: 0
-};