gdc-sdk-node-ts 2.4.13 → 2.4.16

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

@@ -297,7 +297,7 @@ export declare class HttpRuntimeClient implements NodeRuntimeClient {
      * route with optional filters.
      */
     listOrganizationLicenses(ctx: RouteContext, input?: LicenseListRuntimeSearchInput): Promise<SubmitAndPollResult>;
-    /** Adds zero-cost employee seats when the target GW is a test-network. */
+    /** @deprecated Professional seats use Employee Offer and confirmed Order. */
     addFreeOrganizationEmployeeLicenses(ctx: RouteContext, input: OrganizationEmployeeLicenseAddInput): Promise<SubmitAndPollResult>;
     searchOrganizationLicenseOffers(ctx: RouteContext, input: LicenseOfferRuntimeSearchInput): Promise<SubmitAndPollResult>;
     listOrganizationLicenseOffers(ctx: RouteContext, input?: LicenseOfferRuntimeSearchInput): Promise<SubmitAndPollResult>;

package/dist/node-runtime-client.js

@@ -371,6 +371,7 @@ export class HttpRuntimeClient {
     async provisionOrganizationEmployee(ctx, input) {
         return provisionOrganizationEmployeeWithDeps(ctx, input, {
             createEmployee: (routeContext, creation) => this.createOrganizationEmployee(routeContext, creation),
+            confirmLicenseOrder: (routeContext, licenseOrder) => this.confirmOrganizationLicenseOrder(routeContext, licenseOrder),
             issueLicense: (routeContext, invitation) => this.issueOrganizationEmployeeLicense(routeContext, invitation),
         });
     }
@@ -473,7 +474,7 @@ export class HttpRuntimeClient {
             submitAndPoll: this.submitAndPoll.bind(this),
         });
     }
-    /** Adds zero-cost employee seats when the target GW is a test-network. */
+    /** @deprecated Professional seats use Employee Offer and confirmed Order. */
     async addFreeOrganizationEmployeeLicenses(ctx, input) {
         return addFreeOrganizationEmployeeLicensesWithDeps(ctx, input, {
             organizationLicenseActionPath: this.paths.organizationLicenseActionPath.bind(this.paths),

package/dist/orchestration/organization-controller-sdk.d.ts

@@ -83,7 +83,7 @@ export declare class OrganizationControllerSdk {
      * Lists organization-owned license seats with optional filters.
      */
     listLicenses(ctx: RouteContext, input?: LicenseListRuntimeSearchInput): Promise<SubmitAndPollResult>;
-    /** Adds zero-cost employee seats on an explicitly configured test network. */
+    /** @deprecated Professional seats use Employee Offer and confirmed Order. */
     addFreeEmployeeLicenses(ctx: RouteContext, input: OrganizationEmployeeLicenseAddInput): Promise<SubmitAndPollResult>;
     /**
      * Searches commercial license offers known for the current organization.

package/dist/orchestration/organization-controller-sdk.js

@@ -111,7 +111,7 @@ export class OrganizationControllerSdk {
     listLicenses(ctx, input = {}) {
         return requireClientMethod(this.client, 'listOrganizationLicenses')(ctx, input);
     }
-    /** Adds zero-cost employee seats on an explicitly configured test network. */
+    /** @deprecated Professional seats use Employee Offer and confirmed Order. */
     addFreeEmployeeLicenses(ctx, input) {
         return requireClientMethod(this.client, 'addFreeOrganizationEmployeeLicenses')(ctx, input);
     }

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

@@ -1,26 +1,47 @@
 import { type EmployeeActivationGrant, type OrganizationEmployeeLifecycleRecord } from 'gdc-common-utils-ts';
 import type { RouteContext } from './individual-onboarding.js';
 import type { SubmitAndPollResult } from './orchestration/client-port.js';
+import type { OrganizationLicenseOrderConfirmInput } from './organization-license-order.js';
 import type { ServerProfileEnrollmentInput, ServerProfileRecord } from './server-profile-session.js';
 import type { LicenseListRuntimeSearchInput, OrganizationEmployeeCreationInput, OrganizationEmployeeLicenseInvitationInput, OrganizationEmployeeSearchInput } from './resource-operations.js';
-/** Input for the atomic controller-facing create plus seat issuance workflow. */
+/**
+ * Input for atomic interactive provisioning. Every current employee create is
+ * seat-required. Supplying `licenseOrder` authorizes the SDK to close a
+ * GW-issued Offer before retrying creation and issuing the activation
+ * credential. A future batch import requires a separate explicit operation.
+ */
 export type OrganizationEmployeeProvisioningInput = Readonly<{
     creation: OrganizationEmployeeCreationInput;
     invitation: OrganizationEmployeeLicenseInvitationInput;
+    licenseOrder?: Omit<OrganizationLicenseOrderConfirmInput, 'offerId'>;
 }>;
 /** Results required by a portal to persist routing and display the credential once. */
 export type OrganizationEmployeeProvisioningResult = Readonly<{
     employee: SubmitAndPollResult;
     license: SubmitAndPollResult;
+    licenseOrder?: SubmitAndPollResult;
     activationCode: string;
 }>;
 /** Shared dependencies for the create plus seat issuance workflow. */
 export type OrganizationEmployeeProvisioningDeps = Readonly<{
     createEmployee(routeContext: RouteContext, input: OrganizationEmployeeCreationInput): Promise<SubmitAndPollResult>;
     issueLicense(routeContext: RouteContext, input: OrganizationEmployeeLicenseInvitationInput): Promise<SubmitAndPollResult>;
+    confirmLicenseOrder?(routeContext: RouteContext, input: OrganizationLicenseOrderConfirmInput): Promise<SubmitAndPollResult>;
 }>;
-/** Creates the employee, reserves its seat and returns the exact GW credential. */
+/**
+ * Creates the employee, closing Offer/Order first when the strict request has
+ * no available seat, then reserves that seat through `License/_issue` and
+ * returns the exact GW activation credential.
+ */
 export declare function provisionOrganizationEmployeeWithDeps(routeContext: RouteContext, input: OrganizationEmployeeProvisioningInput, deps: OrganizationEmployeeProvisioningDeps): Promise<OrganizationEmployeeProvisioningResult>;
+/**
+ * Reads the pending seat Offer from an employee-create response.
+ *
+ * Portal BFFs use this boundary when payment is asynchronous: persist the
+ * server-owned creation intent, redirect to hosted Checkout, then submit the
+ * paid reference in Order before retrying employee creation and License/_issue.
+ */
+export declare function readEmployeeLicenseOfferId(value: unknown): string | undefined;
 /**
  * Rejects failed outer HTTP responses and failed entries hidden inside a
  * successful async poll envelope before a caller starts the next mutation.

package/dist/organization-employee-lifecycle.js

@@ -2,17 +2,59 @@
 import { createHash } from 'node:crypto';
 import { ActorKinds, EmployeeActivationGrantVersions, projectOrganizationEmployeeLifecycle, readEmployeeActivationCode, } from 'gdc-common-utils-ts';
 import { buildStableActorIdentifier } from 'gdc-common-utils-ts/utils/actor-identifier';
-/** Creates the employee, reserves its seat and returns the exact GW credential. */
+import { ClaimsOfferSchemaorg } from 'gdc-common-utils-ts/constants/schemaorg';
+/**
+ * Creates the employee, closing Offer/Order first when the strict request has
+ * no available seat, then reserves that seat through `License/_issue` and
+ * returns the exact GW activation credential.
+ */
 export async function provisionOrganizationEmployeeWithDeps(routeContext, input, deps) {
-    const employee = await deps.createEmployee(routeContext, input.creation);
+    const creation = input.creation;
+    let employee = await deps.createEmployee(routeContext, creation);
     assertSuccessfulEmployeeOperation('employee creation', employee);
+    let licenseOrder;
+    const offerId = readEmployeeLicenseOfferId(employee.poll.body);
+    if (offerId) {
+        if (!input.licenseOrder || !deps.confirmLicenseOrder) {
+            throw new Error('provisionOrganizationEmployee: employee creation requires Offer/Order confirmation before licence issue.');
+        }
+        licenseOrder = await deps.confirmLicenseOrder(routeContext, {
+            ...input.licenseOrder,
+            offerId,
+        });
+        assertSuccessfulEmployeeOperation('licence order confirmation', licenseOrder);
+        employee = await deps.createEmployee(routeContext, creation);
+        assertSuccessfulEmployeeOperation('employee creation retry', employee);
+        if (readEmployeeLicenseOfferId(employee.poll.body)) {
+            throw new Error('provisionOrganizationEmployee: employee creation still requires a licence after Order confirmation.');
+        }
+    }
     const license = await deps.issueLicense(routeContext, input.invitation);
     assertSuccessfulEmployeeOperation('licence issue', license);
     const activationCode = readEmployeeActivationCode(license.poll.body);
     if (!activationCode) {
         throw new Error('provisionOrganizationEmployee: GW response did not contain an employee activation credential.');
     }
-    return { employee, license, activationCode };
+    return { employee, license, licenseOrder, activationCode };
+}
+/**
+ * Reads the pending seat Offer from an employee-create response.
+ *
+ * Portal BFFs use this boundary when payment is asynchronous: persist the
+ * server-owned creation intent, redirect to hosted Checkout, then submit the
+ * paid reference in Order before retrying employee creation and License/_issue.
+ */
+export function readEmployeeLicenseOfferId(value) {
+    for (const candidate of nestedRecords(value)) {
+        if (candidate.type !== 'Employee-license-offer-v1.0')
+            continue;
+        const meta = record(candidate.meta);
+        const claims = record(meta?.claims);
+        const offerId = String(claims?.[ClaimsOfferSchemaorg.identifier] || '').trim();
+        if (offerId)
+            return offerId;
+    }
+    return undefined;
 }
 /**
  * Rejects failed outer HTTP responses and failed entries hidden inside a

package/dist/resource-operations.d.ts

@@ -669,14 +669,8 @@ type OrganizationLicenseMutationDeps = {
     organizationLicenseActionPollPath: (ctx: RouteContext, action: string) => string;
     submitAndPoll: IndividualLicenseMutationDeps['submitAndPoll'];
 };
-/**
- * Requests additional zero-cost employee seats from a GW test-network.
- * Production callers must use the provider-payment and confirmed Order flow;
- * the gateway enforces that environment boundary independently of this SDK.
- * The request keeps the canonical outer DIDComm identity fields because secure
- * transports sign this envelope before encrypting it for the gateway.
- */
-export declare function addFreeOrganizationEmployeeLicensesWithDeps(routeCtx: RouteContext, input: OrganizationEmployeeLicenseAddInput, deps: OrganizationLicenseMutationDeps): Promise<SubmitAndPollResult>;
+/** @deprecated Professional seats always use Employee Offer and confirmed Order. */
+export declare function addFreeOrganizationEmployeeLicensesWithDeps(_routeCtx: RouteContext, _input: OrganizationEmployeeLicenseAddInput, _deps: OrganizationLicenseMutationDeps): Promise<SubmitAndPollResult>;
 /**
  * Reserves one available household/member seat for a selected contact.
  *

package/dist/resource-operations.js

@@ -243,29 +243,9 @@ export async function searchIndividualLicensesWithDeps(routeCtx, input, deps) {
 export async function listIndividualLicensesWithDeps(routeCtx, input, deps) {
     return searchIndividualLicensesWithDeps(routeCtx, input || {}, deps);
 }
-/**
- * Requests additional zero-cost employee seats from a GW test-network.
- * Production callers must use the provider-payment and confirmed Order flow;
- * the gateway enforces that environment boundary independently of this SDK.
- * The request keeps the canonical outer DIDComm identity fields because secure
- * transports sign this envelope before encrypting it for the gateway.
- */
-export async function addFreeOrganizationEmployeeLicensesWithDeps(routeCtx, input, deps) {
-    const entry = buildLicensePurchaseEntry({
-        quantity: input.quantity,
-        userClass: 'employee',
-        type: 'web',
-        price: 0,
-        priceCurrency: 'EUR',
-    });
-    return deps.submitAndPoll(deps.organizationLicenseActionPath(routeCtx, '_add'), deps.organizationLicenseActionPollPath(routeCtx, '_add'), {
-        jti: `jti-${createRuntimeUuid()}`,
-        iss: routeCtx.tenantId,
-        aud: routeCtx.tenantId,
-        type: 'application/didcomm-plain+json',
-        thid: input.requestThid || `organization-license-add-${createRuntimeUuid()}`,
-        body: { resourceType: 'Bundle', type: 'batch', data: [entry] },
-    }, input.pollOptions);
+/** @deprecated Professional seats always use Employee Offer and confirmed Order. */
+export async function addFreeOrganizationEmployeeLicensesWithDeps(_routeCtx, _input, _deps) {
+    throw new Error('Professional seats require Employee Offer and Order payment verification; License/_add is not supported.');
 }
 /**
  * Reserves one available household/member seat for a selected contact.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdc-sdk-node-ts",
-  "version": "2.4.13",
+  "version": "2.4.16",
   "description": "Next-generation Node runtime package for the GDC SDK family",
   "license": "Apache-2.0",
   "author": "Antifraud Services Inc.",
@@ -12,6 +12,7 @@
   ],
   "scripts": {
     "build": "tsc -p tsconfig.json",
+    "prepare": "npm run build",
     "type-check": "tsc -p tsconfig.json --noEmit",
     "check:product-neutrality": "node scripts/check-product-neutrality.mjs",
     "prepublishOnly": "npm run check:product-neutrality && npm run type-check && npm test",
@@ -37,7 +38,7 @@
     "test:e2e:live-gw:clean": "bash ./scripts/run-live-gw-clean.sh"
   },
   "dependencies": {
-    "gdc-common-utils-ts": "2.5.7",
+    "gdc-common-utils-ts": "2.5.12",
     "gdc-sdk-core-ts": "~2.3.18"
   },
   "devDependencies": {