gdc-sdk-front-ts 0.6.7 → 0.7.0

package/README.md

@@ -86,7 +86,7 @@ Main references:
 
 Use:
 
-- `EmployeeBundleSession` for employee create/search payloads
+- `BundleEditor` for employee create/search/disable/purge payloads
 - `CommunicationAttachedBundleSession` for `Communication`-carried bundles
 - `createConsentAccessEditor(...)` for consent editing inside a communication bundle
 
@@ -114,24 +114,26 @@ Those actor families should start from their own business flow:
 
 ### Create
 
-Use `EmployeeBundleSession` to prepare one employee create bundle. The browser
+Use `BundleEditor` to prepare one employee create bundle. The browser
 does not send it directly to GW CORE.
 The portal backend wraps it into its own request/envelope, then applies KMS,
 DIDComm, submit, and poll.
 
 ```ts
-import { EmployeeBundleSession } from 'gdc-sdk-core-ts';
+import { BundleEditor } from 'gdc-sdk-core-ts';
 import {
   EXAMPLE_EMPLOYEE_DOCTOR_ACTIVE,
   EXAMPLE_PROVIDER_ORGANIZATION_DID,
 } from 'gdc-common-utils-ts/examples';
 import { ClaimsPersonSchemaorg } from 'gdc-common-utils-ts/constants/schemaorg';
+import { EmployeeBundleOperations } from 'gdc-common-utils-ts/utils/employee';
 
 // This editor lives only in frontend memory.
 // It helps the UI build the canonical employee payload before sending it to
 // the portal backend.
-const bundleEditor = new EmployeeBundleSession()
-  .setIdentifier(EXAMPLE_EMPLOYEE_DOCTOR_ACTIVE.identifier)
+const bundle = new BundleEditor()
+  .setBundleOperation(EmployeeBundleOperations.create)
+  .newEntry()
   .setEmail(EXAMPLE_EMPLOYEE_DOCTOR_ACTIVE.email)
   .setRole(EXAMPLE_EMPLOYEE_DOCTOR_ACTIVE.role)
   .addClaim(ClaimsPersonSchemaorg.memberOf, EXAMPLE_PROVIDER_ORGANIZATION_DID);
@@ -139,13 +141,51 @@ const bundleEditor = new EmployeeBundleSession()
 // `employeeCreateBatchBundle` is the canonical one-entry employee `_batch` bundle.
 // Your Vite frontend normally sends this bundle to its own backend, not
 // directly to GW CORE.
-const employeeCreateBatchBundle = bundleEditor.toBundleBatch({
-  method: 'POST',
-  resourceId: EXAMPLE_EMPLOYEE_DOCTOR_ACTIVE.identifier,
-});
+const generatedEmployeeIdentifier = bundle.getIdentifier();
+const employeeCreateBatchBundle = bundle.doneEntry().build();
 console.log(employeeCreateBatchBundle);
 ```
 
+If the frontend does not provide an employee identifier up front, the create
+flow can generate one and keep it in the same editor:
+
+```ts
+import { EmployeeBundleOperations } from 'gdc-common-utils-ts/utils/employee';
+
+const bundle = new BundleEditor()
+  .setBundleOperation(EmployeeBundleOperations.create)
+  .newEntry()
+  .setEmail(EXAMPLE_EMPLOYEE_DOCTOR_ACTIVE.email)
+  .setRole(EXAMPLE_EMPLOYEE_DOCTOR_ACTIVE.role);
+
+const employeeCreateBatchBundle = bundle.doneEntry().build();
+const generatedEmployeeIdentifier = bundle.getIdentifier();
+```
+
+If a frontend needs explicit claim-level control instead of only `setEmail()` /
+`setRole()`, the same editor also exposes generic claim methods:
+
+```ts
+import { BundleEditor } from 'gdc-sdk-core-ts';
+import {
+  EXAMPLE_EMPLOYEE_DOCTOR_ACTIVE,
+  EXAMPLE_PROVIDER_ORGANIZATION_DID,
+} from 'gdc-common-utils-ts/examples';
+import { ClaimsPersonSchemaorg } from 'gdc-common-utils-ts/constants/schemaorg';
+import { EmployeeBundleOperations } from 'gdc-common-utils-ts/utils/employee';
+
+const bundle = new BundleEditor()
+  .setBundleOperation(EmployeeBundleOperations.create)
+  .newEntry(EXAMPLE_EMPLOYEE_DOCTOR_ACTIVE.identifier)
+  .setClaim(ClaimsPersonSchemaorg.email, EXAMPLE_EMPLOYEE_DOCTOR_ACTIVE.email)
+  .setClaim(ClaimsPersonSchemaorg.hasOccupationalRoleValue, EXAMPLE_EMPLOYEE_DOCTOR_ACTIVE.role)
+  .addClaim(ClaimsPersonSchemaorg.memberOf, EXAMPLE_PROVIDER_ORGANIZATION_DID);
+
+console.log(bundle.getClaim(ClaimsPersonSchemaorg.email));
+
+const employeeCreateBatchBundle = bundle.doneEntry().build();
+```
+
 ### Search
 
 Search is a different operation and should be built separately.
@@ -153,13 +193,17 @@ Search is a different operation and should be built separately.
 `email + role` is the recommended exact operational lookup.
 
 ```ts
-import { EmployeeBundleSession } from 'gdc-sdk-core-ts';
+import { BundleEditor } from 'gdc-sdk-core-ts';
 import { EXAMPLE_EMPLOYEE_DOCTOR_ACTIVE } from 'gdc-common-utils-ts/examples';
+import { EmployeeBundleOperations } from 'gdc-common-utils-ts/utils/employee';
 
-const employeeSearchBundle = new EmployeeBundleSession()
+const employeeSearchBundle = new BundleEditor()
+  .setBundleOperation(EmployeeBundleOperations.search)
+  .newEntry()
   .setEmail(EXAMPLE_EMPLOYEE_DOCTOR_ACTIVE.email)
   .setRole(EXAMPLE_EMPLOYEE_DOCTOR_ACTIVE.role)
-  .toBundleSearch();
+  .doneEntry()
+  .build();
 
 console.log(employeeSearchBundle);
 ```
@@ -177,15 +221,15 @@ Disable is a lifecycle operation. Today the shared employee editor still
 produces the canonical `_batch` bundle with inner `request.method = DELETE`.
 
 ```ts
-import { EmployeeBundleSession } from 'gdc-sdk-core-ts';
+import { BundleEditor } from 'gdc-sdk-core-ts';
 import { EXAMPLE_EMPLOYEE_DOCTOR_ACTIVE } from 'gdc-common-utils-ts/examples';
+import { EmployeeBundleOperations } from 'gdc-common-utils-ts/utils/employee';
 
-const employeeDisableBatchBundle = new EmployeeBundleSession()
-  .setIdentifier(EXAMPLE_EMPLOYEE_DOCTOR_ACTIVE.identifier)
-  .toBundleBatch({
-    method: 'DELETE',
-    resourceId: EXAMPLE_EMPLOYEE_DOCTOR_ACTIVE.identifier,
-  });
+const employeeDisableBatchBundle = new BundleEditor()
+  .setBundleOperation(EmployeeBundleOperations.disable)
+  .newEntry(EXAMPLE_EMPLOYEE_DOCTOR_ACTIVE.identifier)
+  .doneEntry()
+  .build();
 
 console.log(employeeDisableBatchBundle);
 ```
@@ -202,12 +246,11 @@ Current GW CORE contract vs preferred target:
 Conceptual `PATCH` example for state change:
 
 ```ts
-const employeeDisablePatchBatchBundle = new EmployeeBundleSession()
-  .setIdentifier(EXAMPLE_EMPLOYEE_DOCTOR_ACTIVE.identifier)
-  .toBundleBatch({
-    method: 'PATCH',
-    resourceId: EXAMPLE_EMPLOYEE_DOCTOR_ACTIVE.identifier,
-  });
+import { EmployeeBundleOperations } from 'gdc-common-utils-ts/utils/employee';
+
+const employeeDisablePatchBatchBundle = new BundleEditor()
+  .setBundleOperation(EmployeeBundleOperations.disable)
+  .newEntry(EXAMPLE_EMPLOYEE_DOCTOR_ACTIVE.identifier);
 ```
 
 Business meaning:
@@ -219,19 +262,23 @@ Business meaning:
 
 ### Purge
 
-Purge is not the same contract as create/disable. The portal backend or runtime
-calls the explicit `Employee/_purge` flow and normally identifies the employee
-with `identifier`.
+Purge is not the same route as create/disable, but the frontend should still
+prepare a `Bundle` for it. The portal backend or runtime later submits that
+bundle to the explicit `Employee/_purge` flow. The canonical purge selector is
+the employee `identifier`.
 
 ```ts
-import { EmployeeBundleSession } from 'gdc-sdk-core-ts';
+import { BundleEditor } from 'gdc-sdk-core-ts';
 import { EXAMPLE_EMPLOYEE_DOCTOR_ACTIVE } from 'gdc-common-utils-ts/examples';
+import { EmployeeBundleOperations } from 'gdc-common-utils-ts/utils/employee';
 
-const employeePurgeSelector = new EmployeeBundleSession()
-  .setIdentifier(EXAMPLE_EMPLOYEE_DOCTOR_ACTIVE.identifier)
-  .toClaims();
+const employeePurgeBundle = new BundleEditor()
+  .setBundleOperation(EmployeeBundleOperations.purge)
+  .newEntry(EXAMPLE_EMPLOYEE_DOCTOR_ACTIVE.identifier)
+  .doneEntry()
+  .build();
 
-console.log(employeePurgeSelector);
+console.log(employeePurgeBundle);
 ```
 
 Primary references for those employee flows:
@@ -276,11 +323,12 @@ Minimal confidential-app example:
 
 ```ts
 import { ClientSDK } from 'gdc-sdk-front-ts';
-import { EmployeeBundleSession } from 'gdc-sdk-core-ts';
+import { BundleEditor } from 'gdc-sdk-core-ts';
 import {
   EXAMPLE_EMPLOYEE_DOCTOR_ACTIVE,
   EXAMPLE_PROFILE_SESSION_INPUT,
 } from 'gdc-common-utils-ts/examples';
+import { EmployeeBundleOperations } from 'gdc-common-utils-ts/utils/employee';
 
 const appId = frontendAppConfig.appId;
 const client = new ClientSDK({ appId });
@@ -291,10 +339,13 @@ const client = new ClientSDK({ appId });
 const session = await client.initializeSession(EXAMPLE_PROFILE_SESSION_INPUT);
 
 // The shared editor from sdk-core is still used to model the employee bundle.
-const employeeSearchBundle = new EmployeeBundleSession()
+const employeeSearchBundle = new BundleEditor()
+  .setBundleOperation(EmployeeBundleOperations.search)
+  .newEntry()
   .setEmail(EXAMPLE_EMPLOYEE_DOCTOR_ACTIVE.email)
   .setRole(EXAMPLE_EMPLOYEE_DOCTOR_ACTIVE.role)
-  .toBundleSearch();
+  .doneEntry()
+  .build();
 
 console.log(session, employeeSearchBundle);
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdc-sdk-front-ts",
-  "version": "0.6.7",
+  "version": "0.7.0",
   "description": "Next-generation frontend runtime package for the GDC SDK family",
   "license": "Apache-2.0",
   "author": "Antifraud Services Inc.",
@@ -17,8 +17,8 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.28.4",
-    "gdc-common-utils-ts": "^1.14.15",
-    "gdc-sdk-core-ts": "^0.6.14"
+    "gdc-common-utils-ts": "^1.15.0",
+    "gdc-sdk-core-ts": "^0.7.0"
   },
   "devDependencies": {
     "@types/node": "^20.14.10",