gdc-sdk-node-ts 0.9.1 → 0.12.0

package/dist/resource-operations.js

@@ -1,5 +1,8 @@
 // Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
-import { HealthcareBasicSections } from 'gdc-common-utils-ts/constants';
+import { HealthcareBasicSections, ResourceTypesFhirR4 } from 'gdc-common-utils-ts/constants';
+import { Format } from 'gdc-common-utils-ts/constants/Schemas';
+import { RelatedPersonClaim } from 'gdc-common-utils-ts/models/interoperable-claims/related-person-claims';
+import { createInteroperableResourceOperationEditor, IndividualOrganizationLifecycleDraft, LicenseOfferSearchEditor, LicenseOrderSearchEditor, InteroperableLifecycleStatuses, LicenseListSearchEditor, } from 'gdc-common-utils-ts';
 import { GwCoreLifecycleRequestMethod, GwCoreLifecycleRequestType, GwCoreLifecycleTodo, } from './constants/lifecycle.js';
 import { buildEmployeeBatchEntry, buildEmployeeSearchBundle, } from 'gdc-sdk-core-ts';
 export async function createOrganizationEmployeeWithDeps(routeCtx, input, options, deps) {
@@ -43,6 +46,69 @@ export async function searchOrganizationEmployeesWithDeps(routeCtx, input, deps)
         body: buildEmployeeSearchBundle({ claims: input.employeeClaims }),
     }, input.pollOptions);
 }
+/**
+ * Searches license seats for one organization/tenant through `License/_search`.
+ */
+export async function searchOrganizationLicensesWithDeps(routeCtx, input, deps) {
+    return deps.submitAndPoll(deps.organizationLicenseSearchPath(routeCtx), deps.organizationLicenseSearchPollPath(routeCtx), {
+        thid: input.requestThid || `organization-license-search-${createRuntimeUuid()}`,
+        body: {
+            resourceType: 'Bundle',
+            type: 'batch',
+            entry: [
+                new LicenseListSearchEditor(input.licenseQuery || {})
+                    .buildSearchEntry(),
+            ],
+        },
+    }, input.pollOptions);
+}
+/**
+ * Lists license seats using the same canonical `License/_search` route with no
+ * mandatory filters.
+ */
+export async function listOrganizationLicensesWithDeps(routeCtx, input, deps) {
+    return searchOrganizationLicensesWithDeps(routeCtx, input || {}, deps);
+}
+/**
+ * Searches commercial license offers for one organization/tenant through
+ * `Offer/_search`.
+ */
+export async function searchOrganizationLicenseOffersWithDeps(routeCtx, input, deps) {
+    return deps.submitAndPoll(deps.organizationLicenseOfferSearchPath(routeCtx), deps.organizationLicenseOfferSearchPollPath(routeCtx), {
+        thid: input.requestThid || `organization-license-offer-search-${createRuntimeUuid()}`,
+        body: {
+            resourceType: 'Bundle',
+            type: 'batch',
+            data: [
+                new LicenseOfferSearchEditor(input.offerQuery || {})
+                    .buildSearchEntry(),
+            ],
+        },
+    }, input.pollOptions);
+}
+export async function listOrganizationLicenseOffersWithDeps(routeCtx, input, deps) {
+    return searchOrganizationLicenseOffersWithDeps(routeCtx, input || {}, deps);
+}
+/**
+ * Searches commercial license orders/payment projections for one
+ * organization/tenant through `Order/_search`.
+ */
+export async function searchOrganizationLicenseOrdersWithDeps(routeCtx, input, deps) {
+    return deps.submitAndPoll(deps.organizationLicenseOrderSearchPath(routeCtx), deps.organizationLicenseOrderSearchPollPath(routeCtx), {
+        thid: input.requestThid || `organization-license-order-search-${createRuntimeUuid()}`,
+        body: {
+            resourceType: 'Bundle',
+            type: 'batch',
+            data: [
+                new LicenseOrderSearchEditor(input.orderQuery || {})
+                    .buildSearchEntry(),
+            ],
+        },
+    }, input.pollOptions);
+}
+export async function listOrganizationLicenseOrdersWithDeps(routeCtx, input, deps) {
+    return searchOrganizationLicenseOrdersWithDeps(routeCtx, input || {}, deps);
+}
 export async function disableIndividualOrganizationWithDeps(routeCtx, input, options, deps) {
     // TODO(gw-core-lifecycle-target-patch-individual-disable): migrate from
     // explicit `_disable` to `_batch + PATCH` only after GW CORE supports it.
@@ -66,6 +132,62 @@ export async function purgeIndividualOrganizationWithDeps(routeCtx, input, optio
     });
     return deps.submitAndPoll(deps.individualOrganizationPurgePath(routeCtx), deps.individualOrganizationPurgePollPath(routeCtx), payload, options);
 }
+/**
+ * Searches license seats for one individual/family controller context through
+ * the shared `License/_search` route.
+ */
+export async function searchIndividualLicensesWithDeps(routeCtx, input, deps) {
+    return deps.submitAndPoll(deps.individualLicenseSearchPath(routeCtx), deps.individualLicenseSearchPollPath(routeCtx), {
+        thid: input.requestThid || `individual-license-search-${createRuntimeUuid()}`,
+        body: {
+            resourceType: 'Bundle',
+            type: 'batch',
+            entry: [
+                new LicenseListSearchEditor(input.licenseQuery || {})
+                    .buildSearchEntry(),
+            ],
+        },
+    }, input.pollOptions);
+}
+/**
+ * Lists license seats for the individual/family side using the same canonical
+ * search route without mandatory filters.
+ */
+export async function listIndividualLicensesWithDeps(routeCtx, input, deps) {
+    return searchIndividualLicensesWithDeps(routeCtx, input || {}, deps);
+}
+export async function searchIndividualLicenseOffersWithDeps(routeCtx, input, deps) {
+    return deps.submitAndPoll(deps.individualLicenseOfferSearchPath(routeCtx), deps.individualLicenseOfferSearchPollPath(routeCtx), {
+        thid: input.requestThid || `individual-license-offer-search-${createRuntimeUuid()}`,
+        body: {
+            resourceType: 'Bundle',
+            type: 'batch',
+            data: [
+                new LicenseOfferSearchEditor(input.offerQuery || {})
+                    .buildSearchEntry(),
+            ],
+        },
+    }, input.pollOptions);
+}
+export async function listIndividualLicenseOffersWithDeps(routeCtx, input, deps) {
+    return searchIndividualLicenseOffersWithDeps(routeCtx, input || {}, deps);
+}
+export async function searchIndividualLicenseOrdersWithDeps(routeCtx, input, deps) {
+    return deps.submitAndPoll(deps.individualLicenseOrderSearchPath(routeCtx), deps.individualLicenseOrderSearchPollPath(routeCtx), {
+        thid: input.requestThid || `individual-license-order-search-${createRuntimeUuid()}`,
+        body: {
+            resourceType: 'Bundle',
+            type: 'batch',
+            data: [
+                new LicenseOrderSearchEditor(input.orderQuery || {})
+                    .buildSearchEntry(),
+            ],
+        },
+    }, input.pollOptions);
+}
+export async function listIndividualLicenseOrdersWithDeps(routeCtx, input, deps) {
+    return searchIndividualLicenseOrdersWithDeps(routeCtx, input || {}, deps);
+}
 export async function importIpsOrFhirAndUpdateIndexWithDeps(routeCtx, input, deps) {
     const payload = {
         thid: input.compositionPayload.thid || `composition-${createRuntimeUuid()}`,
@@ -79,6 +201,65 @@ export async function importIpsOrFhirAndUpdateIndexWithDeps(routeCtx, input, dep
         : deps.individualCompositionR4PollPath(routeCtx);
     return deps.submitAndPoll(submitPath, pollPath, payload, input.pollOptions);
 }
+export async function disableIndividualMemberWithDeps(routeCtx, input, options, deps) {
+    const claims = {
+        '@context': String(input.memberClaims?.['@context'] || Format.FHIR_API).trim() || Format.FHIR_API,
+        ...(input.memberClaims || {}),
+    };
+    const resource = createInteroperableResourceOperationEditor()
+        .setResourceType(ResourceTypesFhirR4.RelatedPerson)
+        .setIdentifierClaimKey(RelatedPersonClaim.IdentifierValue)
+        .setBusinessIdentifier(String(claims[RelatedPersonClaim.IdentifierValue] || claims[RelatedPersonClaim.Identifier] || '').trim())
+        .setClaims(claims)
+        .setLifecycleStatus(InteroperableLifecycleStatuses.Inactive)
+        .buildLifecycleResource();
+    const payload = {
+        thid: `relatedperson-disable-${createRuntimeUuid()}`,
+        body: {
+            resourceType: 'Bundle',
+            type: 'batch',
+            entry: [{
+                    request: { method: GwCoreLifecycleRequestMethod.Post },
+                    meta: { claims },
+                    resource: {
+                        ...resource,
+                        ...(input.resourceId ? { id: input.resourceId } : {}),
+                    },
+                }],
+        },
+    };
+    return deps.submitAndPoll(deps.individualRelatedPersonBatchPath(routeCtx), deps.individualRelatedPersonPollPath(routeCtx), payload, options);
+}
+export async function purgeIndividualMemberWithDeps(routeCtx, input, options, deps) {
+    const claims = {
+        '@context': String(input.memberClaims?.['@context'] || Format.FHIR_API).trim() || Format.FHIR_API,
+        ...(input.memberClaims || {}),
+    };
+    const resource = createInteroperableResourceOperationEditor()
+        .setResourceType(ResourceTypesFhirR4.RelatedPerson)
+        .setIdentifierClaimKey(RelatedPersonClaim.IdentifierValue)
+        .setBusinessIdentifier(String(claims[RelatedPersonClaim.IdentifierValue] || claims[RelatedPersonClaim.Identifier] || '').trim())
+        .setClaims(claims)
+        .setLifecycleStatus(InteroperableLifecycleStatuses.Purged)
+        .buildLifecycleResource();
+    const payload = {
+        thid: `relatedperson-purge-${createRuntimeUuid()}`,
+        body: {
+            resourceType: 'Bundle',
+            type: 'batch',
+            entry: [{
+                    type: input.dataType || GwCoreLifecycleRequestType.IndividualMemberPurge,
+                    request: { method: GwCoreLifecycleRequestMethod.Post },
+                    meta: { claims },
+                    resource: {
+                        ...resource,
+                        ...(input.resourceId ? { id: input.resourceId } : {}),
+                    },
+                }],
+        },
+    };
+    return deps.submitAndPoll(deps.individualRelatedPersonPurgePath(routeCtx), deps.individualRelatedPersonPurgePollPath(routeCtx), payload, options);
+}
 export async function upsertRelatedPersonAndPollWithDeps(routeCtx, input, deps) {
     const payload = {
         thid: input.relatedPersonPayload.thid || `relatedperson-${createRuntimeUuid()}`,
@@ -204,23 +385,19 @@ function buildEmployeeLifecyclePayload(input) {
 }
 function buildIndividualOrganizationLifecyclePayload(input) {
     const claims = input.organizationClaims || {};
+    const payload = new IndividualOrganizationLifecycleDraft()
+        .setClaims(claims)
+        .setRequestType(input.requestType)
+        .setThreadId(`${input.thidPrefix}-${createRuntimeUuid()}`);
+    if (input.resourceId) {
+        payload.setResourceId(input.resourceId);
+    }
     return {
         jti: `jti-${createRuntimeUuid()}`,
         iss: input.routeCtx.tenantId,
         aud: input.routeCtx.tenantId,
         type: 'application/didcomm-plain+json',
-        thid: `${input.thidPrefix}-${createRuntimeUuid()}`,
-        body: {
-            data: [{
-                    type: input.requestType,
-                    request: { method: GwCoreLifecycleRequestMethod.Post },
-                    meta: { claims },
-                    resource: {
-                        ...(input.resourceId ? { id: input.resourceId } : {}),
-                        meta: { claims },
-                    },
-                }],
-        },
+        ...payload.buildCurrentGwPayload(),
     };
 }
 function buildBundleSearchQuery(input) {

package/dist/session.js

@@ -30,7 +30,7 @@ export class ActorSession {
     }
     asHostOnboarding() {
         this.assertActorKind(ActorKinds.HostOnboarding);
-        return new HostOnboardingSdk(this.requireClient());
+        return new HostOnboardingSdk(this.requireClient(), this.capabilities);
     }
     asOrganizationController() {
         this.assertActorKind(ActorKinds.OrganizationController);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdc-sdk-node-ts",
-  "version": "0.9.1",
+  "version": "0.12.0",
   "description": "Next-generation Node runtime package for the GDC SDK family",
   "license": "Apache-2.0",
   "author": "Antifraud Services Inc.",
@@ -13,12 +13,21 @@
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "type-check": "tsc -p tsconfig.json --noEmit",
+    "local:close": "PORTS=3000 bash ./scripts/local-close.sh",
+    "docker:close": "PORTS=8000 bash ./scripts/local-close.sh",
     "test": "npm run build && node --test tests/*.test.mjs",
-    "test:e2e:live-gw": "npm run build && RUN_LIVE_GW_E2E=1 node --test tests/live-gw-node-runtime.e2e.test.mjs"
+    "test:e2e:live-gw": "npm run build && RUN_LIVE_GW_E2E=1 node --test tests/live-gw-node-runtime.e2e.test.mjs",
+    "test:e2e:live-gw:professional": "npm run build && RUN_LIVE_GW_E2E=1 LIVE_GW_E2E_SUITE=professional node --test tests/live-gw-node-runtime.e2e.test.mjs",
+    "test:e2e:live-gw:individual": "npm run build && RUN_LIVE_GW_E2E=1 LIVE_GW_E2E_SUITE=individual node --test tests/live-gw-node-runtime.e2e.test.mjs",
+    "test:e2e:live-gw:clinical": "npm run build && RUN_LIVE_GW_E2E=1 LIVE_GW_E2E_SUITE=clinical node --test tests/live-gw-node-runtime.e2e.test.mjs",
+    "test:e2e:live-gw:didcomm-plain": "npm run build && RUN_LIVE_GW_E2E=1 LIVE_GW_E2E_TRANSPORT=didcomm-plain node --test tests/live-gw-node-runtime.e2e.test.mjs",
+    "test:e2e:live-gw:legacy-fhir": "npm run build && RUN_LIVE_GW_E2E=1 LIVE_GW_E2E_TRANSPORT=legacy-fhir node --test tests/live-gw-node-runtime.e2e.test.mjs",
+    "test:e2e:live-gw:all": "npm run build && RUN_LIVE_GW_E2E=1 LIVE_GW_E2E_TRANSPORT=all node --test tests/live-gw-node-runtime.e2e.test.mjs",
+    "test:e2e:live-gw:clean": "bash ./scripts/run-live-gw-clean.sh"
   },
   "dependencies": {
-    "gdc-common-utils-ts": "^1.20.1",
-    "gdc-sdk-core-ts": "^0.9.1"
+    "gdc-common-utils-ts": "^1.24.0",
+    "gdc-sdk-core-ts": "^0.11.0"
   },
   "devDependencies": {
     "@types/node": "^20.14.10",