dataspace-client-sdk-node 0.1.1 → 0.1.2

package/src/types.ts

@@ -195,6 +195,17 @@ export type FamilyOrganizationSummary = {
   updatedAt?: string;
 };
 
+export type OfferPreview = {
+  offerId?: string;
+  amount?: string;
+  currency?: string;
+  seats?: number;
+  planName?: string;
+  sku?: string;
+  paymentMethod?: string;
+  checkoutUrl?: string;
+};
+
 /**
  * Input for organization activation in GW using ICA-derived proof material.
  *
@@ -203,12 +214,43 @@ export type FamilyOrganizationSummary = {
  */
 export type GatewayOrganizationActivationInput = {
   vpToken: string;
+  /** Generic requested seats/members for initial offer sizing. Defaults to 2. */
+  numberOfMembers?: number;
+  organizationVc?: string;
+  legalRepresentativeVc?: string;
+  regulatoryEvidence?: Record<string, unknown>;
+  /** @deprecated Prefer `numberOfMembers` and explicit input fields. */
+  additionalClaims?: Record<string, unknown>;
+};
+
+export type GatewayOrganizationActivationSimpleInput = {
+  jurisdiction?: string;
+  sector?: string;
+  vpToken: string;
+  serviceProviderDidWeb?: string;
+  serviceProviderUrl?: string;
+  controllerEmail?: string;
+  controllerTelephone?: string;
+  controllerRole: string;
+  numberOfMembers?: number;
+  timeoutSeconds?: number;
+  intervalSeconds?: number;
   organizationVc?: string;
   legalRepresentativeVc?: string;
   regulatoryEvidence?: Record<string, unknown>;
   additionalClaims?: Record<string, unknown>;
 };
 
+export type LegalOrganizationOrderSimpleInput = {
+  jurisdiction?: string;
+  sector?: string;
+  offerId: string;
+  timeoutSeconds?: number;
+  intervalSeconds?: number;
+  dataType?: string;
+  additionalClaims?: Record<string, unknown>;
+};
+
 /**
  * Input for device activation based on activation code exchange + DCR.
  */
@@ -219,6 +261,17 @@ export type EmployeeDeviceActivationInput = {
   pollOptions?: PollOptions;
 };
 
+export type EmployeeDeviceActivationSimpleInput = {
+  tenantId?: string;
+  jurisdiction?: string;
+  sector?: string;
+  activationCode: string;
+  idToken: string;
+  dcrPayload: Record<string, unknown>;
+  timeoutSeconds?: number;
+  intervalSeconds?: number;
+};
+
 /**
  * Result of device activation flow.
  *
@@ -256,6 +309,40 @@ export type SubjectOrganizationBootstrapResult = {
   confirmation?: SubmitAndPollResult;
 };
 
+export type IndividualOrganizationBootstrapSimpleInput = {
+  tenantId?: string;
+  jurisdiction?: string;
+  sector?: string;
+  alternateName: string;
+  controllerEmail?: string;
+  controllerTelephone?: string;
+  controllerRole?: string; // default org.hl7.v3.RoleCode|RESPRSN
+  timeoutSeconds?: number;
+  intervalSeconds?: number;
+  additionalClaims?: Record<string, unknown>;
+};
+
+export type IndividualOrganizationBootstrapSimpleResult = {
+  registration: SubmitAndPollResult;
+  offerId: string;
+  confirmation: SubmitAndPollResult;
+};
+
+export type IndividualOrganizationStartSimpleResult = {
+  registration: SubmitAndPollResult;
+  offerId: string;
+  offerPreview: OfferPreview;
+};
+
+export type IndividualOrganizationConfirmOrderSimpleInput = {
+  tenantId?: string;
+  jurisdiction?: string;
+  sector?: string;
+  offerId: string;
+  timeoutSeconds?: number;
+  intervalSeconds?: number;
+};
+
 /**
  * Input for UC 5.5 IPS/FHIR import and index update.
  */
@@ -413,6 +500,8 @@ export type ClientOptions = {
   bearerToken?: string;
   defaultHeaders?: Record<string, string>;
   wallet?: WalletProvider;
+  /** Optional default tenant context so calls can omit ctx repeatedly. */
+  ctx?: RouteContext;
 };
 
 /**
@@ -487,6 +576,18 @@ export type SmartTokenExchangeInput = {
   path?: string;
 };
 
+export type SmartTokenRequestSimpleInput = {
+  tenantId?: string;
+  jurisdiction?: string;
+  sector?: string;
+  idToken: string;
+  scopes: string[];
+  endpointId?: string;
+  timeoutSeconds?: number;
+  intervalSeconds?: number;
+  additionalClaims?: Record<string, unknown>;
+};
+
 export type SmartTokenExchangeResult = {
   status: 'fetched' | 'cached' | 'failed';
   accessToken?: string;

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,
+  );
+});