dataspace-client-sdk-node 0.1.1

package/examples/e2e-bootstrap-tenant.mjs

@@ -0,0 +1,126 @@
+import { DataspaceNodeClient } from '../dist/index.js';
+
+function parseCsv(value, fallback = []) {
+  const items = String(value || '')
+    .split(',')
+    .map((item) => item.trim())
+    .filter(Boolean);
+  return items.length ? items : fallback;
+}
+
+function parseBool(value, fallback = false) {
+  if (value === undefined) return fallback;
+  const normalized = String(value).trim().toLowerCase();
+  if (['1', 'true', 'yes', 'y', 'on'].includes(normalized)) return true;
+  if (['0', 'false', 'no', 'n', 'off'].includes(normalized)) return false;
+  return fallback;
+}
+
+function requiredEnv(name) {
+  const value = String(process.env[name] || '').trim();
+  if (!value) throw new Error(`Missing required env var: ${name}`);
+  return value;
+}
+
+function readOptionalJson(envName) {
+  const raw = String(process.env[envName] || '').trim();
+  if (!raw) return undefined;
+  return JSON.parse(raw);
+}
+
+function pickDiagnostics(result) {
+  return (
+    result?.poll?.body?.issues?.issue?.[0]?.diagnostics ||
+    result?.poll?.body?.body?.issues?.issue?.[0]?.diagnostics ||
+    ''
+  );
+}
+
+const baseUrl = process.env.BASE_URL || 'http://localhost:3000';
+const authMode = (process.env.AUTH_MODE || 'demo').trim().toLowerCase();
+const hostCtx = {
+  jurisdiction: process.env.JURISDICTION || 'ES',
+  sector: process.env.HOST_REGISTRY_SECTOR || 'test',
+};
+const tenantCtx = {
+  tenantId: process.env.TENANT_ID || 'acme',
+  jurisdiction: process.env.JURISDICTION || 'ES',
+  sector: process.env.SECTOR || 'health-care',
+};
+
+const pollOptions = {
+  timeoutMs: Number(process.env.POLL_TIMEOUT_MS || 120000),
+  intervalMs: Number(process.env.POLL_INTERVAL_MS || 2000),
+};
+
+async function resolveClient() {
+  if (authMode === 'pkce') {
+    const authClient = new DataspaceNodeClient({ baseUrl });
+    const auth = await authClient.authenticateBackendPkceAndExchange({
+      ctx: tenantCtx,
+      apiKey: requiredEnv('GW_API_KEY'),
+      controllerPublicJwk: readOptionalJson('GW_CONTROLLER_PUBLIC_JWK_SIGN') || readOptionalJson('GW_PUBLIC_JWK'),
+      scopes: parseCsv(process.env.GW_AUTH_SCOPES, ['onboarding', 'employee.write']),
+      endpointId: process.env.GW_AUTH_ENDPOINT_ID || 'e2e-bootstrap',
+      codeVerifier: process.env.GW_PKCE_CODE_VERIFIER,
+      pollOptions,
+    });
+    if (auth.status === 'failed' || !auth.accessToken) {
+      throw new Error(`PKCE auth failed at step ${auth.step || 'unknown'}.`);
+    }
+    return new DataspaceNodeClient({ baseUrl, bearerToken: auth.accessToken });
+  }
+
+  return new DataspaceNodeClient({
+    baseUrl,
+    bearerToken: process.env.AUTH_BEARER || 'demo-token',
+  });
+}
+
+async function main() {
+  const client = await resolveClient();
+
+  const activation = await client.activateOrganizationInGatewayFromIcaProof(
+    hostCtx,
+    {
+      vpToken: requiredEnv('VP_TOKEN'),
+      organizationVc: process.env.ORGANIZATION_VC_JWT,
+      legalRepresentativeVc: process.env.LEGAL_REPRESENTATIVE_VC_JWT,
+    },
+    pollOptions,
+  );
+
+  console.log(`[activate] http=${activation.poll.status}`);
+  if (activation.poll.status !== 200) {
+    const diagnostics = pickDiagnostics(activation);
+    throw new Error(`Organization activation failed (status=${activation.poll.status})${diagnostics ? `: ${diagnostics}` : ''}`);
+  }
+
+  if (!parseBool(process.env.CREATE_CONTROLLER_EMPLOYEE, false)) {
+    console.log('[employee] skipped (CREATE_CONTROLLER_EMPLOYEE=false)');
+    return;
+  }
+
+  const employee = await client.createOrganizationEmployee(
+    tenantCtx,
+    {
+      employeeClaims: {
+        '@context': 'org.schema',
+        'org.schema.Person.email': process.env.CONTROLLER_EMAIL || 'controller@example.com',
+        'org.schema.Person.hasOccupation': process.env.CONTROLLER_ROLE || 'ISCO-08|1342',
+      },
+    },
+    pollOptions,
+  );
+
+  console.log(`[employee] http=${employee.poll.status}`);
+  if (employee.poll.status !== 200) {
+    const diagnostics = pickDiagnostics(employee);
+    throw new Error(`Controller employee creation failed (status=${employee.poll.status})${diagnostics ? `: ${diagnostics}` : ''}`);
+  }
+}
+
+main().catch((error) => {
+  console.error('[e2e-bootstrap-tenant] ERROR:', error?.message || error);
+  process.exit(1);
+});

package/examples/e2e-individual-flow.mjs

@@ -0,0 +1,43 @@
+import { DataspaceNodeClient, createDidcommPlainMessage } from '../dist/index.js';
+
+const baseUrl = process.env.BASE_URL || 'http://localhost:3000';
+const bearerToken = process.env.AUTH_BEARER || 'demo-token';
+
+const client = new DataspaceNodeClient({ baseUrl, bearerToken });
+const ctx = {
+  tenantId: process.env.TENANT_ID || 'acme',
+  jurisdiction: process.env.JURISDICTION || 'ES',
+  sector: process.env.SECTOR || 'health-care',
+};
+
+const payload = createDidcommPlainMessage({
+  iss: 'adult1@example.com',
+  aud: 'did:web:api.acme.org',
+  body: {
+    data: [
+      {
+        type: 'Family-registration-form-v1.0',
+        meta: {
+          claims: {
+            '@context': 'org.schema',
+            '@type': 'template',
+            'org.schema.Organization.address.addressCountry': 'ES',
+            'org.schema.Organization.identifier.additionalType': 'UUID',
+            'org.schema.Organization.identifier.value': `family-${Date.now()}`,
+            'org.schema.Person.email': 'adult1@example.com',
+            'org.schema.Service.category': ctx.sector,
+            'org.schema.Service.identifier': 'did:web:api-provider.example.com',
+            'org.schema.Service.serviceType': 'http://terminology.hl7.org/CodeSystem/v3-ActReason|SRVC',
+            'org.schema.Service.termsOfService': 'https://provider.example.com/terms',
+          },
+        },
+      },
+    ],
+  },
+});
+
+const submitPath = client.individualFamilyOrganizationBatchPath(ctx);
+const pollPath = client.individualFamilyOrganizationPollPath(ctx);
+const result = await client.submitAndPoll(submitPath, pollPath, payload, { timeoutMs: 30000, intervalMs: 2000 });
+
+console.log(JSON.stringify(result, null, 2));

package/examples/host-activate-and-employee.mjs

@@ -0,0 +1,75 @@
+import { DataspaceNodeClient, createDidcommPlainMessage } from '../dist/index.js';
+
+const baseUrl = process.env.BASE_URL || 'http://localhost:3000';
+const bearerToken = process.env.AUTH_BEARER || 'demo-token';
+
+const client = new DataspaceNodeClient({ baseUrl, bearerToken });
+
+const hostCtx = {
+  jurisdiction: process.env.JURISDICTION || 'ES',
+  sector: process.env.HOST_REGISTRY_SECTOR || 'test-network',
+};
+
+const tenantCtx = {
+  tenantId: process.env.TENANT_ID || 'acme',
+  jurisdiction: process.env.JURISDICTION || 'ES',
+  sector: process.env.SECTOR || 'health-care',
+};
+
+// 1) Host organization activation
+const activatePayload = createDidcommPlainMessage({
+  iss: 'did:web:controller.example.com',
+  aud: 'did:web:host.example.com',
+  body: {
+    data: [
+      {
+        type: 'Organization-activation-request-v1.0',
+        meta: {
+          claims: {
+            '@context': 'org.schema',
+            'Organization.identifier': process.env.TENANT_URN || 'urn:example:tenant',
+            vp_token: process.env.VP_TOKEN || '<vp-token-placeholder>',
+          },
+        },
+      },
+    ],
+  },
+});
+
+const activateSubmitPath = client.hostRegistryOrganizationActivatePath(hostCtx);
+const activatePollPath = client.hostRegistryOrganizationActivatePollPath(hostCtx);
+const activation = await client.submitAndPoll(activateSubmitPath, activatePollPath, activatePayload, {
+  timeoutMs: 120000,
+  intervalMs: 5000,
+});
+
+console.log('Activation status:', activation.poll.status);
+
+// 2) Employee creation under tenant
+const employeePayload = createDidcommPlainMessage({
+  iss: 'did:web:api.acme.org:employee:admin1@acme.org:device:<uuid>',
+  aud: 'did:web:api.acme.org',
+  body: {
+    data: [
+      {
+        type: 'Employee-registration-request-v1.0',
+        meta: {
+          claims: {
+            '@context': 'org.schema',
+            'org.schema.Person.email': process.env.EMPLOYEE_EMAIL || 'doctor1@acme.org',
+            'org.schema.Person.hasOccupation': process.env.EMPLOYEE_ROLE || 'ISCO-08|2211',
+          },
+        },
+      },
+    ],
+  },
+});
+
+const employeeSubmitPath = client.employeeBatchPath(tenantCtx);
+const employeePollPath = client.employeePollPath(tenantCtx);
+const employee = await client.submitAndPoll(employeeSubmitPath, employeePollPath, employeePayload, {
+  timeoutMs: 120000,
+  intervalMs: 5000,
+});
+
+console.log('Employee status:', employee.poll.status);

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "dataspace-client-sdk-node",
+  "version": "0.1.1",
+  "description": "Node.js SDK skeleton for GW/UNID DIDComm plain batch + async polling flows",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "type-check": "tsc -p tsconfig.json --noEmit",
+    "test": "npm run build && node --test tests/*.test.mjs",
+    "example:e2e-bootstrap-tenant": "npm run build && node examples/e2e-bootstrap-tenant.mjs"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.0",
+    "typescript": "^5.1.6"
+  },
+  "dependencies": {
+    "@noble/post-quantum": "^0.6.1",
+    "gdc-common-utils-ts": "^1.4.8",
+    "node-fetch": "^3.3.2"
+  }
+}

package/src/builders.ts

@@ -0,0 +1,28 @@
+import type { DidcommPlainMessage } from './types.js';
+
+export function createDidcommPlainMessage(input: {
+  iss: string;
+  aud: string;
+  body: Record<string, unknown>;
+  type?: string;
+  jti?: string;
+  thid?: string;
+}): DidcommPlainMessage {
+  const random = Math.random().toString(36).slice(2, 10);
+  const now = Date.now();
+  const thid = input.thid ?? `thid-${now}-${random}`;
+  const jti = input.jti ?? `jti-${now}-${random}`;
+
+  return {
+    jti,
+    thid,
+    iss: input.iss,
+    aud: input.aud,
+    type: input.type ?? 'application/api+json',
+    body: input.body,
+  };
+}
+
+export function buildAsyncPollRequest(thid: string): { thid: string } {
+  return { thid };
+}