dataspace-client-sdk-node 0.1.1 → 0.2.0

package/tests/client.test.mjs

@@ -268,6 +268,10 @@ test('activateOrganizationInGatewayFromIcaProof submits activation and polls to
     assert.equal(result.submit.status, 202);
     assert.equal(result.poll.status, 200);
     assert.equal(calls[0].url, 'http://localhost:3000/host/cds-ES/v1/test/registry/org.schema/Organization/_activate');
+    const submitPayload = JSON.parse(calls[0].options.body);
+    assert.equal(submitPayload.body.vp_token, 'vp-token-001');
+    assert.equal(submitPayload.body.organizationCredential, 'org-vc-jwt');
+    assert.equal(submitPayload.body.representativeCredential, 'legal-vc-jwt');
   } finally {
     globalThis.fetch = originalFetch;
   }
@@ -388,6 +392,90 @@ test('bootstrapSubjectOrganizationIndex runs registration and confirmation flow'
   }
 });
 
+test('bootstrapIndividualOrganizationSimple registers individual org and confirms family order', async () => {
+  const calls = [];
+  const originalFetch = globalThis.fetch;
+
+  globalThis.fetch = async (url, options) => {
+    calls.push({ url: String(url), options, body: options?.body ? JSON.parse(options.body) : undefined });
+    if (calls.length === 1 || calls.length === 3) return jsonResponse({ accepted: true }, 202);
+    if (calls.length === 2) {
+      return jsonResponse({
+        body: { data: [{ meta: { claims: { 'org.schema.Offer.identifier': 'urn:offer:family-001' } } }] },
+      }, 200);
+    }
+    return jsonResponse({ status: 'COMPLETED' }, 200);
+  };
+
+  try {
+    const client = new DataspaceNodeClient({
+      baseUrl: 'http://localhost:3000',
+      bearerToken: 'controller-token',
+      ctx: { tenantId: 'acme', jurisdiction: 'ES', sector: 'health-care' },
+    });
+    const result = await client.bootstrapIndividualOrganizationSimple({
+      alternateName: 'ana',
+      controllerTelephone: 'tel:+34600111222',
+    });
+
+    assert.equal(result.offerId, 'urn:offer:family-001');
+    assert.equal(result.registration.poll.status, 200);
+    assert.equal(result.confirmation.poll.status, 200);
+    assert.equal(
+      calls[0].url,
+      'http://localhost:3000/acme/cds-ES/v1/health-care/individual/org.schema/Organization/_batch',
+    );
+    assert.equal(
+      calls[2].url,
+      'http://localhost:3000/acme/cds-ES/v1/health-care/individual/org.schema/Order/_batch',
+    );
+    const registrationClaims = calls[0].body?.body?.data?.[0]?.meta?.claims || {};
+    assert.equal(registrationClaims['org.schema.Organization.alternateName'], 'ana');
+    assert.equal(registrationClaims['org.schema.Service.category'], 'health-care');
+    assert.equal(registrationClaims['org.schema.Person.telephone'], 'tel:+34600111222');
+    assert.equal(registrationClaims['org.schema.Person.hasOccupation'], 'org.hl7.v3.RoleCode|RESPRSN');
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('startIndividualOrganizationSimple + confirmIndividualOrganizationOrderSimple support explicit offer acceptance UX', async () => {
+  const calls = [];
+  const originalFetch = globalThis.fetch;
+
+  globalThis.fetch = async (url, options) => {
+    calls.push({ url: String(url), options, body: options?.body ? JSON.parse(options.body) : undefined });
+    if (calls.length === 1 || calls.length === 3) return jsonResponse({ accepted: true }, 202);
+    if (calls.length === 2) {
+      return jsonResponse({
+        body: { data: [{ meta: { claims: { 'org.schema.Offer.identifier': 'urn:offer:family-002', 'org.schema.Offer.price': '0.00' } } }] },
+      }, 200);
+    }
+    return jsonResponse({ status: 'COMPLETED' }, 200);
+  };
+
+  try {
+    const client = new DataspaceNodeClient({
+      baseUrl: 'http://localhost:3000',
+      bearerToken: 'controller-token',
+      ctx: { tenantId: 'acme', jurisdiction: 'ES', sector: 'health-care' },
+    });
+    const started = await client.startIndividualOrganizationSimple({
+      alternateName: 'maria',
+      controllerEmail: 'maria@example.com',
+    });
+    assert.equal(started.offerId, 'urn:offer:family-002');
+    assert.equal(started.offerPreview.amount, '0.00');
+
+    const confirmed = await client.confirmIndividualOrganizationOrderSimple({
+      offerId: started.offerId,
+    });
+    assert.equal(confirmed.poll.status, 200);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
 test('importIpsOrFhirAndUpdateIndex submits Composition in individual section', async () => {
   const calls = [];
   const originalFetch = globalThis.fetch;
@@ -523,6 +611,88 @@ test('requestSmartToken exchanges token in separate step', async () => {
   }
 });
 
+test('requestSmartTokenSimple uses identity auth exchange async flow with default ctx', async () => {
+  const calls = [];
+  const originalFetch = globalThis.fetch;
+
+  globalThis.fetch = async (url, options) => {
+    calls.push({ url: String(url), options });
+    if (calls.length === 1) return jsonResponse({ accepted: true }, 202);
+    return jsonResponse({
+      access_token: 'smart-token-ctx-001',
+      token_type: 'Bearer',
+      scope: 'employee.healthcare.getIndexComposition',
+      expires_in: 3600,
+    }, 200);
+  };
+
+  try {
+    const client = new DataspaceNodeClient({
+      baseUrl: 'http://localhost:3000',
+      ctx: { tenantId: 'acme', jurisdiction: 'ES', sector: 'health-care' },
+    });
+
+    const result = await client.requestSmartTokenSimple({
+      idToken: 'employee-id-token-001',
+      scopes: ['employee.healthcare.getIndexComposition'],
+      timeoutSeconds: 5,
+      intervalSeconds: 0.001,
+    });
+
+    assert.equal(result.status, 'fetched');
+    assert.equal(result.accessToken, 'smart-token-ctx-001');
+    assert.equal(calls.length, 2);
+    assert.equal(calls[0].url, 'http://localhost:3000/host/cds-ES/v1/health-care/acme/identity/auth/_exchange');
+    assert.equal(calls[1].url, 'http://localhost:3000/host/cds-ES/v1/health-care/acme/identity/auth/_exchange-response');
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('activateEmployeeDeviceWithActivationCodeSimple uses one-object input and default ctx', async () => {
+  const calls = [];
+  const originalFetch = globalThis.fetch;
+
+  globalThis.fetch = async (url, options) => {
+    calls.push({ url: String(url), options });
+    switch (calls.length) {
+      case 1:
+        return jsonResponse({ accepted: true }, 202); // exchange submit
+      case 2:
+        return jsonResponse({ body: { initial_access_token: 'initial-access-simple-001' } }, 200); // exchange poll
+      case 3:
+        return jsonResponse({ accepted: true }, 202); // dcr submit
+      default:
+        return jsonResponse({ body: { client_id: 'did:web:device-simple-001' } }, 200); // dcr poll
+    }
+  };
+
+  try {
+    const client = new DataspaceNodeClient({
+      baseUrl: 'http://localhost:3000',
+      ctx: { tenantId: 'acme', jurisdiction: 'ES', sector: 'health-care' },
+    });
+    const result = await client.activateEmployeeDeviceWithActivationCodeSimple({
+      activationCode: 'ACT-SIMPLE-001',
+      idToken: 'user-id-token-001',
+      dcrPayload: {
+        application_type: 'web',
+        client_name: 'Acme Portal',
+        token_endpoint_auth_method: 'private_key_jwt',
+      },
+      timeoutSeconds: 5,
+      intervalSeconds: 0.001,
+    });
+
+    assert.equal(result.initialAccessToken, 'initial-access-simple-001');
+    assert.equal(calls.length, 4);
+    assert.equal(calls[0].url, 'http://localhost:3000/host/cds-ES/v1/health-care/acme/identity/auth/_exchange');
+    assert.equal(calls[2].url, 'http://localhost:3000/host/cds-ES/v1/health-care/acme/identity/auth/_dcr');
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
 test('generateDigitalTwinFromSubjectData submits digital twin Composition', async () => {
   const calls = [];
   const originalFetch = globalThis.fetch;
@@ -890,3 +1060,324 @@ test('searchFamilyOrganization returns null for not_found status', async () => {
     globalThis.fetch = originalFetch;
   }
 });
+
+test('offer helpers extract offerId and preview from activation-like response', () => {
+  const client = new DataspaceNodeClient({ baseUrl: 'http://localhost:3000' });
+  const result = {
+    poll: {
+      body: {
+        body: {
+          data: [{
+            meta: {
+              claims: {
+                'org.schema.Offer.identifier': 'urn:offer:abc',
+                'org.schema.Offer.price': '0.00',
+                'org.schema.Offer.priceCurrency': 'EUR',
+                'org.schema.Offer.eligibleQuantity.value': 2,
+                'org.schema.Offer.itemOffered.name': 'License Tier XS',
+                'org.schema.Offer.itemOffered.sku': 'portal-web',
+                'org.schema.Offer.acceptedPaymentMethod': 'Stripe',
+                'org.schema.Offer.checkoutPageURLTemplate': 'https://pay.example.com/checkout/123',
+              },
+            },
+          }],
+        },
+      },
+    },
+  };
+
+  assert.equal(client.getOfferIdFromResponse(result), 'urn:offer:abc');
+  const preview = client.getOfferPreviewFromResponse(result);
+  assert.equal(preview.offerId, 'urn:offer:abc');
+  assert.equal(preview.amount, '0.00');
+  assert.equal(preview.currency, 'EUR');
+  assert.equal(preview.seats, 2);
+  assert.equal(preview.planName, 'License Tier XS');
+  assert.equal(preview.sku, 'portal-web');
+  assert.equal(preview.paymentMethod, 'Stripe');
+  assert.equal(preview.checkoutUrl, 'https://pay.example.com/checkout/123');
+});
+
+test('activateOrganizationInGatewaySimple maps single-object input and seconds options', async () => {
+  const calls = [];
+  const originalFetch = globalThis.fetch;
+
+  globalThis.fetch = async (url, options) => {
+    calls.push({ url: String(url), options, body: options?.body ? JSON.parse(options.body) : undefined });
+    if (calls.length === 1) return jsonResponse({ accepted: true }, 202);
+    return jsonResponse({ status: 'COMPLETED' }, 200);
+  };
+
+  try {
+    const client = new DataspaceNodeClient({ baseUrl: 'http://localhost:3000', bearerToken: 'tok' });
+    const result = await client.activateOrganizationInGatewaySimple({
+      jurisdiction: 'ES',
+      sector: 'health-care',
+      vpToken: 'vp-001',
+      serviceProviderUrl: 'https://api.acme.org',
+      controllerEmail: 'admin@acme.org',
+      controllerRole: 'ISCO-08|1112',
+      numberOfMembers: 3,
+      timeoutSeconds: 5,
+      intervalSeconds: 1,
+    });
+
+    assert.equal(result.poll.status, 200);
+    assert.equal(calls[0].url, 'http://localhost:3000/host/cds-ES/v1/health-care/registry/org.schema/Organization/_activate');
+    const claims = calls[0].body?.body?.data?.[0]?.meta?.claims || {};
+    assert.equal(claims.vp_token, 'vp-001');
+    assert.equal(claims['org.schema.Organization.numberOfEmployees'], 3);
+    assert.equal(claims['org.schema.Service.category'], 'health-care');
+    assert.equal(claims['org.schema.Service.identifier'], 'did:web:api.acme.org');
+    assert.equal(claims['org.schema.Service.url'], 'https://api.acme.org');
+    assert.equal(claims['org.schema.Person.email'], 'admin@acme.org');
+    assert.equal(claims['org.schema.Person.hasOccupation'], 'ISCO-08|1112');
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('confirmLegalOrganizationOrderSimple builds order payload from single object', async () => {
+  const calls = [];
+  const originalFetch = globalThis.fetch;
+
+  globalThis.fetch = async (url, options) => {
+    calls.push({ url: String(url), options, body: options?.body ? JSON.parse(options.body) : undefined });
+    if (calls.length === 1) return jsonResponse({ accepted: true }, 202);
+    return jsonResponse({ status: 'COMPLETED' }, 200);
+  };
+
+  try {
+    const client = new DataspaceNodeClient({ baseUrl: 'http://localhost:3000', bearerToken: 'tok' });
+    const result = await client.confirmLegalOrganizationOrderSimple({
+      jurisdiction: 'ES',
+      sector: 'health-care',
+      offerId: 'urn:offer:xyz',
+      timeoutSeconds: 5,
+      intervalSeconds: 1,
+    });
+
+    assert.equal(result.poll.status, 200);
+    assert.equal(calls[0].url, 'http://localhost:3000/host/cds-ES/v1/health-care/registry/org.schema/Order/_batch');
+    const claims = calls[0].body?.body?.data?.[0]?.meta?.claims || {};
+    assert.equal(claims['Order.acceptedOffer.identifier'], 'urn:offer:xyz');
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('constructor default ctx allows onboarding calls without passing ctx each time', async () => {
+  const calls = [];
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async (url, options) => {
+    calls.push({ url: String(url), options, body: options?.body ? JSON.parse(options.body) : undefined });
+    if (calls.length === 1) return jsonResponse({ accepted: true }, 202); // activate submit
+    if (calls.length === 2) {
+      return jsonResponse({
+        body: { data: [{ meta: { claims: { 'org.schema.Offer.identifier': 'urn:offer:def' } } }] },
+      }, 200); // activate poll
+    }
+    if (calls.length === 3) return jsonResponse({ accepted: true }, 202); // order submit
+    return jsonResponse({ status: 'COMPLETED' }, 200); // order poll
+  };
+
+  try {
+    const client = new DataspaceNodeClient({
+      baseUrl: 'http://localhost:3000',
+      bearerToken: 'tok',
+      ctx: { tenantId: 'acme', jurisdiction: 'ES', sector: 'health-care' },
+    });
+    const activation = await client.activateOrganizationInGatewayFromIcaProof(undefined, { vpToken: 'vp-ctx-001' }, { timeoutMs: 5000, intervalMs: 1 });
+    const offerId = client.getOfferIdFromResponse(activation);
+    assert.equal(offerId, 'urn:offer:def');
+    const legalOrgOrder = await client.confirmLegalOrganizationOrderSimple({
+      jurisdiction: 'ES',
+      sector: 'health-care',
+      offerId: offerId,
+      timeoutSeconds: 5,
+      intervalSeconds: 1,
+    });
+    assert.equal(legalOrgOrder.poll.status, 200);
+    assert.equal(calls[0].url, 'http://localhost:3000/host/cds-ES/v1/health-care/registry/org.schema/Organization/_activate');
+    assert.equal(calls[2].url, 'http://localhost:3000/host/cds-ES/v1/health-care/registry/org.schema/Order/_batch');
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('setTenantId/setJurisdiction/setSector configure default ctx for simple methods', async () => {
+  const calls = [];
+  const originalFetch = globalThis.fetch;
+
+  globalThis.fetch = async (url, options) => {
+    calls.push({ url: String(url), options });
+    if (calls.length === 1) return jsonResponse({ accepted: true }, 202);
+    if (calls.length === 2) {
+      return jsonResponse({
+        body: {
+          data: [{
+            meta: { claims: { 'org.schema.Offer.identifier': 'offer-setter-001' } },
+          }],
+        },
+      }, 200);
+    }
+    if (calls.length === 3) return jsonResponse({ accepted: true }, 202);
+    return jsonResponse({ status: 'COMPLETED' }, 200);
+  };
+
+  try {
+    const client = new DataspaceNodeClient({ baseUrl: 'http://localhost:3000', bearerToken: 'id-token' });
+    client.setTenantId('acme').setJurisdiction('ES').setSector('health-care');
+
+    const activation = await client.activateOrganizationInGatewaySimple({
+      vpToken: 'vp-token-001',
+      serviceProviderDidWeb: 'did:web:api.acme.org',
+      controllerEmail: 'owner@acme.org',
+      controllerRole: 'ISCO-08|1112',
+    });
+    const offerId = client.getOfferIdFromResponse(activation);
+    assert.equal(offerId, 'offer-setter-001');
+
+    const order = await client.confirmLegalOrganizationOrderSimple({
+      offerId,
+    });
+    assert.equal(order.poll.status, 200);
+    assert.equal(calls[0].url, 'http://localhost:3000/host/cds-ES/v1/health-care/registry/org.schema/Organization/_activate');
+    assert.equal(calls[2].url, 'http://localhost:3000/host/cds-ES/v1/health-care/registry/org.schema/Order/_batch');
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('setContextOrg configures default ctx for simple methods', async () => {
+  const calls = [];
+  const originalFetch = globalThis.fetch;
+
+  globalThis.fetch = async (url, options) => {
+    calls.push({ url: String(url), options });
+    if (calls.length === 1) return jsonResponse({ accepted: true }, 202);
+    if (calls.length === 2) return jsonResponse({ body: { data: [{ meta: { claims: { 'org.schema.Offer.identifier': 'offer-orgctx-001' } } }] } }, 200);
+    return jsonResponse({ status: 'COMPLETED' }, 200);
+  };
+
+  try {
+    const client = new DataspaceNodeClient({ baseUrl: 'http://localhost:3000', bearerToken: 'id-token' });
+    client.setContextOrg({ tenantId: 'acme', jurisdiction: 'ES', sector: 'health-care' });
+    const activation = await client.activateOrganizationInGatewaySimple({
+      vpToken: 'vp-token-001',
+      serviceProviderUrl: 'portal.acme.org',
+      controllerTelephone: 'tel:+34600111222',
+      controllerRole: 'ISCO-08|1112',
+    });
+    assert.equal(client.getOfferIdFromResponse(activation), 'offer-orgctx-001');
+    assert.equal(calls[0].url, 'http://localhost:3000/host/cds-ES/v1/health-care/registry/org.schema/Organization/_activate');
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('setDefaultTimeoutSeconds and setDefaultIntervalSeconds apply to simple methods', async () => {
+  const calls = [];
+  const originalFetch = globalThis.fetch;
+
+  globalThis.fetch = async (url, options) => {
+    calls.push({ url: String(url), options });
+    if (calls.length === 1) return jsonResponse({ accepted: true }, 202);
+    if (calls.length === 2) return jsonResponse({ status: 'PENDING' }, 202);
+    return jsonResponse({ status: 'COMPLETED' }, 200);
+  };
+
+  try {
+    const client = new DataspaceNodeClient({ baseUrl: 'http://localhost:3000', bearerToken: 'id-token' });
+    client
+      .setContextOrg({ tenantId: 'acme', jurisdiction: 'ES', sector: 'health-care' })
+      .setDefaultTimeoutSeconds(5)
+      .setDefaultIntervalSeconds(0.001);
+
+    const result = await client.activateOrganizationInGatewaySimple({
+      vpToken: 'vp-token-001',
+      serviceProviderDidWeb: 'did:web:api.acme.org',
+      controllerEmail: 'owner@acme.org',
+      controllerRole: 'ISCO-08|1112',
+    });
+
+    assert.equal(result.poll.status, 200);
+    assert.equal(calls.length, 3);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('activateOrganizationInGatewaySimple throws on business-level error in DIDComm entry', async () => {
+  const calls = [];
+  const originalFetch = globalThis.fetch;
+
+  globalThis.fetch = async (url, options) => {
+    calls.push({ url: String(url), options });
+    if (calls.length === 1) return jsonResponse({ accepted: true }, 202);
+    return jsonResponse({
+      data: [{
+        type: 'Organization-activation-request-v1.0',
+        response: {
+          status: '400',
+          outcome: { issue: [{ diagnostics: 'Missing ICA-issued organization credential.' }] },
+        },
+      }],
+      resourceType: 'Bundle',
+      type: 'batch-response',
+      total: 1,
+    }, 200);
+  };
+
+  try {
+    const client = new DataspaceNodeClient({ baseUrl: 'http://localhost:3000' });
+    await assert.rejects(
+      () => client.activateOrganizationInGatewaySimple({
+        jurisdiction: 'ES',
+        sector: 'test',
+        vpToken: 'vp-token-001',
+        serviceProviderDidWeb: 'did:web:api.acme.org',
+        controllerEmail: 'owner@acme.org',
+        controllerRole: 'ISCO-08|1112',
+      }),
+      /Missing ICA-issued organization credential\./,
+    );
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('activateOrganizationInGatewaySimple requires controller identity and role', async () => {
+  const client = new DataspaceNodeClient({ baseUrl: 'http://localhost:3000' });
+  await assert.rejects(
+    () => client.activateOrganizationInGatewaySimple({
+      jurisdiction: 'ES',
+      sector: 'test',
+      vpToken: 'vp-token-001',
+      serviceProviderDidWeb: 'did:web:api.acme.org',
+      controllerRole: 'ISCO-08|1112',
+    }),
+    /requires controllerEmail or controllerTelephone/i,
+  );
+  await assert.rejects(
+    () => client.activateOrganizationInGatewaySimple({
+      jurisdiction: 'ES',
+      sector: 'test',
+      vpToken: 'vp-token-001',
+      serviceProviderDidWeb: 'did:web:api.acme.org',
+      controllerEmail: 'admin@acme.org',
+      controllerRole: '',
+    }),
+    /requires controllerRole/i,
+  );
+  await assert.rejects(
+    () => client.activateOrganizationInGatewaySimple({
+      jurisdiction: 'ES',
+      sector: 'test',
+      vpToken: 'vp-token-001',
+      controllerEmail: 'admin@acme.org',
+      controllerRole: 'ISCO-08|1112',
+    }),
+    /requires serviceProviderDidWeb or serviceProviderUrl/i,
+  );
+});

package/tests/fixtures/ica-vp-minimal.json

@@ -0,0 +1,67 @@
+{
+  "iss": "did:web:controller.example.org",
+  "sub": "did:web:controller.example.org",
+  "aud": "did:web:host.example.com",
+  "vp": {
+    "@context": [
+      "https://www.w3.org/ns/credentials/v2"
+    ],
+    "type": [
+      "VerifiablePresentation"
+    ],
+    "holder": "did:web:controller.example.org",
+    "verifiableCredential": [
+      {
+        "@context": [
+          "https://www.w3.org/ns/credentials/v2",
+          "https://schema.org"
+        ],
+        "type": [
+          "VerifiableCredential",
+          "OrganizationCredential"
+        ],
+        "issuer": "did:web:localhost%3A3310",
+        "credentialSubject": {
+          "id": "did:web:globaldatacare.es:onehealth:organization:taxid:VATES-B00000000",
+          "@type": "Organization",
+          "legalName": "Example Data Provider SL",
+          "taxID": "VATES-B00000000",
+          "sameAs": "did:web:provider.example.org",
+          "url": "provider.example.org",
+          "alternateName": "example-provider",
+          "identifier": "did:web:globaldatacare.es:onehealth:organization:taxid:VATES-B00000000",
+          "identifierType": "TAX",
+          "identifierValue": "VATES-B00000000",
+          "address": {
+            "@type": "PostalAddress",
+            "addressCountry": "ES"
+          }
+        }
+      },
+      {
+        "@context": [
+          "https://www.w3.org/ns/credentials/v2",
+          "https://schema.org"
+        ],
+        "type": [
+          "VerifiableCredential",
+          "PersonCredential",
+          "LegalRepresentativeCredential"
+        ],
+        "issuer": "did:web:localhost%3A3310",
+        "credentialSubject": {
+          "id": "urn:person:identifier:IDCES-99999999R",
+          "@type": "Person",
+          "name": "Alex Example",
+          "identifier": "IDCES-99999999R",
+          "sameAs": "did:web:controller.example.org",
+          "memberOf": {
+            "@type": "Organization",
+            "taxID": "VATES-B00000000"
+          }
+        }
+      }
+    ]
+  }
+}
+

package/tests/helpers/vp-token-fixture.mjs

@@ -0,0 +1,23 @@
+import fs from 'node:fs';
+
+function b64url(input) {
+  return Buffer.from(input).toString('base64url');
+}
+
+export function buildUnsignedVpJwt(payload) {
+  const now = Math.floor(Date.now() / 1000);
+  const header = { alg: 'none', typ: 'JWT' };
+  const claims = {
+    iat: now,
+    exp: now + 600,
+    nonce: `nonce-${now}`,
+    ...payload,
+  };
+  return `${b64url(JSON.stringify(header))}.${b64url(JSON.stringify(claims))}.`;
+}
+
+export function loadVpPayloadFixture(path) {
+  const raw = fs.readFileSync(path, 'utf8');
+  return JSON.parse(raw);
+}
+