gdc-sdk-node-ts 2.6.2 → 2.6.4

package/README.md

@@ -427,13 +427,16 @@ data ingestion/search.
 
 `ProfessionalSdk.requestProfessionalAccess(...)` is the bootstrap operation
 for the inverse flow: it persists a subject-scoped permission-request
-`Communication` using the configured HTTP bearer and transport profile, without
-requiring SMART. The subject later answers through
+`Communication` with an attached batch Bundle of normal
+`Consent.status = draft` resources, using the configured HTTP bearer and
+transport profile without requiring SMART. A draft is inbox evidence and
+cannot authorize access. The subject later answers through
 `respondToProfessionalAccessRequest(...)`; that facade uses the normal Consent
 grant/deny operation and retains the original Communication identifier/thread.
 `listProfessionalAccessRequests(...)` provides the subject/requester inbox view,
 and `GatewayActiveConsentProvider` supplies `evaluateRequestedAccess(...)` from
 the GW Consent source of truth rather than a parallel application table.
+There is no `AccessRequest` FHIR resource or `AccessRequest.*` claim family.
 
 ## Main Flows
 
@@ -813,6 +816,9 @@ Recovery-specific live rule:
   and cannot select another tenant
 - a failed poll `OperationOutcome` is surfaced before the helper checks for
   `initial_access_token`, preserving the real GW diagnostic
+- every asynchronous success test uses `BundleReader.getResponseAnalysis()`;
+  HTTP 200/201 alone is transport completion, not proof that the inner Bundle
+  entries succeeded
 - the bundled recovery runner generates a syntactically valid demo JWT if
   `CONTROLLER_ID_TOKEN` is not provided, but production/staging should use a
   real IdP-issued token

package/dist/node-runtime-client.d.ts

@@ -143,6 +143,13 @@ export declare class HttpRuntimeClient implements NodeRuntimeClient {
     }, pollOptions?: PollOptions): Promise<PollResult>;
     /**
      * Convenience wrapper that performs submit and poll in sequence.
+     *
+     * A terminal HTTP 200/201 means polling completed; it does not guarantee the
+     * business operation succeeded. Consumers and E2E tests must inspect
+     * `result.poll.body` with `BundleReader.getResponseAnalysis()` and reject
+     * error OperationOutcomes. High-level product code must not manually traverse
+     * DIDComm `body`, JSON-API `data[]`, FHIR `entry[]` or `issue[]` to decide
+     * success.
      */
     submitAndPoll(submitPath: string, pollPath: string, payload: SubmitPayload, pollOptions?: PollOptions): Promise<SubmitAndPollResult>;
     /** Registers one neutral FHIR R5 topic in the tenant-owned CORE catalog. */
@@ -496,8 +503,10 @@ export declare class HttpRuntimeClient implements NodeRuntimeClient {
     ingestCommunicationAndUpdateIndex(ctx: RouteContext, input: CommunicationIngestionInput): Promise<SubmitAndPollResult>;
     /**
      * Records a subject-scoped permission-request Communication before SMART
-     * authorization exists. The configured bearer authenticates HTTP and the
-     * configured secure transport adapter signs/encrypts DIDComm when enabled.
+     * authorization exists. The Communication carries a batch Bundle of
+     * `Consent.status = draft`; that draft grants nothing. The configured bearer
+     * authenticates HTTP and the configured secure transport adapter
+     * signs/encrypts DIDComm when enabled.
      */
     requestProfessionalAccess(ctx: RouteContext, input: ProfessionalAccessRequestInput): Promise<ProfessionalAccessRequestResult>;
     /**

package/dist/node-runtime-client.js

@@ -129,6 +129,13 @@ export class HttpRuntimeClient {
     }
     /**
      * Convenience wrapper that performs submit and poll in sequence.
+     *
+     * A terminal HTTP 200/201 means polling completed; it does not guarantee the
+     * business operation succeeded. Consumers and E2E tests must inspect
+     * `result.poll.body` with `BundleReader.getResponseAnalysis()` and reject
+     * error OperationOutcomes. High-level product code must not manually traverse
+     * DIDComm `body`, JSON-API `data[]`, FHIR `entry[]` or `issue[]` to decide
+     * success.
      */
     async submitAndPoll(submitPath, pollPath, payload, pollOptions) {
         return this.submitClinicalMessageAndPoll(submitPath, pollPath, payload, this.transportProfile, pollOptions);
@@ -984,8 +991,10 @@ export class HttpRuntimeClient {
     }
     /**
      * Records a subject-scoped permission-request Communication before SMART
-     * authorization exists. The configured bearer authenticates HTTP and the
-     * configured secure transport adapter signs/encrypts DIDComm when enabled.
+     * authorization exists. The Communication carries a batch Bundle of
+     * `Consent.status = draft`; that draft grants nothing. The configured bearer
+     * authenticates HTTP and the configured secure transport adapter
+     * signs/encrypts DIDComm when enabled.
      */
     async requestProfessionalAccess(ctx, input) {
         this.requireConfiguredTransportProfile(input.transportProfile);

package/dist/orchestration/professional-sdk.d.ts

@@ -77,7 +77,8 @@ export declare class ProfessionalSdk {
     ingestCommunicationAndUpdateIndex(ctx: RouteContext, input: CommunicationIngestionInput): Promise<SubmitAndPollResult>;
     /**
      * Requests subject-controlled access without requiring a SMART token. The
-     * runtime persists one canonical permission-request Communication.
+     * runtime persists one canonical permission-request Communication carrying
+     * a draft Consent Bundle. The draft is auditable but never authorizes access.
      */
     requestProfessionalAccess(ctx: RouteContext, input: ProfessionalAccessRequestInput): Promise<ProfessionalAccessRequestResult>;
     /** Lists permission requests sent by or involving this professional. */

package/dist/orchestration/professional-sdk.js

@@ -92,7 +92,8 @@ export class ProfessionalSdk {
     }
     /**
      * Requests subject-controlled access without requiring a SMART token. The
-     * runtime persists one canonical permission-request Communication.
+     * runtime persists one canonical permission-request Communication carrying
+     * a draft Consent Bundle. The draft is auditable but never authorizes access.
      */
     requestProfessionalAccess(ctx, input) {
         return requireClientMethod(this.client, 'requestProfessionalAccess')(ctx, input);

package/dist/organization-employee-lifecycle.d.ts

@@ -36,6 +36,8 @@ export type OrganizationEmployeeProvisioningDeps = Readonly<{
  * returns the exact GW activation credential.
  */
 export declare function provisionOrganizationEmployeeWithDeps(routeContext: RouteContext, input: OrganizationEmployeeProvisioningInput, deps: OrganizationEmployeeProvisioningDeps): Promise<OrganizationEmployeeProvisioningResult>;
+/** Reads the technical employee id that must own the subsequently issued seat. */
+export declare function readEmployeeResourceId(value: unknown): string | undefined;
 /** Reads the effective positive installation allowance returned by `License/_issue`. */
 export declare function readEmployeeLicenseMaxDevices(value: unknown): number | undefined;
 /**

package/dist/organization-employee-lifecycle.js

@@ -29,7 +29,14 @@ export async function provisionOrganizationEmployeeWithDeps(routeContext, input,
             throw new Error('provisionOrganizationEmployee: employee creation still requires a licence after Order confirmation.');
         }
     }
-    const license = await deps.issueLicense(routeContext, input.invitation);
+    const employeeResourceId = readEmployeeResourceId(employee.poll.body);
+    if (!employeeResourceId) {
+        throw new Error('provisionOrganizationEmployee: GW response did not contain the created employee resource id.');
+    }
+    const license = await deps.issueLicense(routeContext, {
+        ...input.invitation,
+        subjectId: employeeResourceId,
+    });
     assertSuccessfulEmployeeOperation('licence issue', license);
     const activationCode = readEmployeeActivationCode(license.poll.body);
     if (!activationCode) {
@@ -44,6 +51,19 @@ export async function provisionOrganizationEmployeeWithDeps(routeContext, input,
         ...(maxDevices ? { maxDevices } : {}),
     };
 }
+/** Reads the technical employee id that must own the subsequently issued seat. */
+export function readEmployeeResourceId(value) {
+    for (const candidate of nestedRecords(value)) {
+        const response = record(candidate.response);
+        const status = parseHttpStatus(response?.status);
+        if (status !== undefined && (status < 200 || status >= 300))
+            continue;
+        const resourceId = String(record(candidate.resource)?.id || '').trim();
+        if (resourceId)
+            return resourceId;
+    }
+    return undefined;
+}
 /** Reads the effective positive installation allowance returned by `License/_issue`. */
 export function readEmployeeLicenseMaxDevices(value) {
     for (const candidate of nestedRecords(value)) {

package/dist/resource-operations.d.ts

@@ -33,6 +33,8 @@ export type OrganizationEmployeeLicenseInvitationInput = {
     email: string;
     role: string;
     subjectDid: string;
+    /** Technical employee resource id returned by Employee creation. */
+    subjectId?: string;
     type?: DeviceAppType;
     requestThid?: string;
     pollOptions?: {
@@ -268,8 +270,9 @@ export type CommunicationIngestionInput = {
 /**
  * Canonical professional-to-subject permission request.
  *
- * This operation records a `Communication`; it never creates Consent or
- * requires a SMART token. HTTP authentication and optional secure DIDComm
+ * This operation records one `Communication` carrying a normal
+ * `Consent.status = draft`; it never creates an active grant and does not
+ * require a SMART token. HTTP authentication and optional secure DIDComm
  * transport remain concerns of the configured runtime client.
  */
 export type ProfessionalAccessRequestInput = Omit<PermissionRequestCommunicationInput, 'missing'> & Readonly<{
@@ -288,6 +291,7 @@ export type ProfessionalAccessRequestInput = Omit<PermissionRequestCommunication
 export type ProfessionalAccessRequestResult = Readonly<{
     thid: string;
     communicationIdentifier: string;
+    consentIdentifier: string;
     communication: CommunicationInput;
     delivery: SubmitAndPollResult;
 }>;
@@ -846,7 +850,8 @@ export declare function ingestCommunicationAndUpdateIndexWithDeps(routeCtx: Rout
 /**
  * Builds and persists one professional access request against the subject's
  * provider route. The request is deliberately independent from SMART because
- * no subject consent exists yet.
+ * no active subject consent exists yet. The auditable Communication carries a
+ * draft Consent Bundle; the draft itself never authorizes data access.
  */
 export declare function requestProfessionalAccessWithDeps(routeCtx: RouteContext, input: ProfessionalAccessRequestInput, deps: {
     individualCommunicationBatchPath: (ctx: RouteContext, pathFormatSegment: string) => string;

package/dist/resource-operations.js

@@ -70,19 +70,23 @@ export async function issueOrganizationEmployeeLicenseWithDeps(routeCtx, input,
     const email = String(input.email || '').trim().toLowerCase();
     const role = String(input.role || '').trim();
     const subjectDid = String(input.subjectDid || '').trim();
+    const subjectId = String(input.subjectId || '').trim();
     if (!email)
         throw new Error('issueOrganizationEmployeeLicense: email is required.');
     if (!role)
         throw new Error('issueOrganizationEmployeeLicense: role is required.');
     if (!subjectDid)
         throw new Error('issueOrganizationEmployeeLicense: subjectDid is required.');
+    if (!subjectId)
+        throw new Error('issueOrganizationEmployeeLicense: subjectId is required.');
     const entry = buildLicenseIssueEntry({
         email,
         role,
         userClass: DeviceUserClasses.Employee,
         type: input.type || DeviceAppTypes.Web,
+        subjectId,
+        subjectDid,
     });
-    entry.meta.subjectDid = subjectDid;
     return deps.submitAndPoll(deps.identityLicenseIssuePath(routeCtx), deps.identityLicenseIssuePollPath(routeCtx), {
         thid: input.requestThid || `employee-license-issue-${createRuntimeUuid()}`,
         body: {
@@ -476,7 +480,8 @@ export async function ingestCommunicationAndUpdateIndexWithDeps(routeCtx, input,
 /**
  * Builds and persists one professional access request against the subject's
  * provider route. The request is deliberately independent from SMART because
- * no subject consent exists yet.
+ * no active subject consent exists yet. The auditable Communication carries a
+ * draft Consent Bundle; the draft itself never authorizes data access.
  */
 export async function requestProfessionalAccessWithDeps(routeCtx, input, deps) {
     const subject = String(input.subject || '').trim();
@@ -498,11 +503,14 @@ export async function requestProfessionalAccessWithDeps(routeCtx, input, deps) {
     const thid = String(input.thid || '').trim() || `permission-request-${createRuntimeUuid()}`;
     const communicationIdentifier = String(input.communicationIdentifier || '').trim()
         || `urn:uuid:${createRuntimeUuid()}`;
+    const consentIdentifier = String(input.consentIdentifier || '').trim()
+        || `urn:uuid:${createRuntimeUuid()}`;
     const communication = buildPermissionRequestCommunication({
         ...input,
         subject,
         thid,
         communicationIdentifier,
+        consentIdentifier,
         missing: {
             sections: missingSections,
             resourceTypes: missingResourceTypes,
@@ -518,6 +526,23 @@ export async function requestProfessionalAccessWithDeps(routeCtx, input, deps) {
         [CommunicationClaim.NoteText]: communication.text,
     };
     const persistedCommunication = { ...communication, claims: communicationClaims };
+    if (!communication.payload) {
+        throw new Error('Permission request requires one draft Consent Bundle.');
+    }
+    const communicationResource = addFhirResourceToCommunication(createCommunicationResource({
+        subject,
+        sender: communication.sender,
+        recipient: communication.recipient,
+        category: Array.isArray(communication.category)
+            ? communication.category
+            : communication.category ? [communication.category] : undefined,
+        noteText: communication.text,
+        claims: communicationClaims,
+    }), communication.payload, {
+        attachmentTitle: 'draft-consent-request.json',
+        attachmentContentType: 'application/fhir+json',
+    });
+    communicationResource.id = communicationIdentifier;
     const communicationPayload = {
         thid,
         body: {
@@ -526,12 +551,7 @@ export async function requestProfessionalAccessWithDeps(routeCtx, input, deps) {
             data: [{
                     type: 'CommMsgExtended',
                     meta: { claims: communicationClaims },
-                    resource: {
-                        resourceType: ResourceTypesFhirR4.Communication,
-                        id: communicationIdentifier,
-                        status: 'completed',
-                        meta: { claims: communicationClaims },
-                    },
+                    resource: communicationResource,
                 }],
         },
     };
@@ -543,7 +563,13 @@ export async function requestProfessionalAccessWithDeps(routeCtx, input, deps) {
         pathFormatSegment: 'r4',
         pollOptions: input.pollOptions,
     }, deps);
-    return { thid, communicationIdentifier, communication: persistedCommunication, delivery };
+    return {
+        thid,
+        communicationIdentifier,
+        consentIdentifier,
+        communication: persistedCommunication,
+        delivery,
+    };
 }
 export async function searchCommunicationParticipantsWithDeps(routeCtx, input, deps) {
     const payload = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdc-sdk-node-ts",
-  "version": "2.6.2",
+  "version": "2.6.4",
   "description": "Next-generation Node runtime package for the GDC SDK family",
   "license": "Apache-2.0",
   "author": "Antifraud Services Inc.",
@@ -38,8 +38,8 @@
     "test:e2e:live-gw:clean": "bash ./scripts/run-live-gw-clean.sh"
   },
   "dependencies": {
-    "gdc-common-utils-ts": "2.7.1",
-    "gdc-sdk-core-ts": "2.4.2"
+    "gdc-common-utils-ts": "2.7.3",
+    "gdc-sdk-core-ts": "2.4.3"
   },
   "devDependencies": {
     "@types/node": "^20.14.10",