gdc-common-utils-ts 1.24.3 → 2.0.2

package/dist/utils/license-offer-order.d.ts

@@ -19,7 +19,7 @@ export type LicenseOrderSummary = Readonly<{
     currency?: string;
     seats?: number;
 }>;
-export type LicenseOfferOrderDraft = Readonly<{
+export type LicenseOfferOrderState = Readonly<{
     offer: LicenseOfferPreview;
     order: LicenseOrderSummary;
     baseClaims: LicenseClaims;
@@ -32,25 +32,25 @@ export type LicenseOfferOrderDraft = Readonly<{
  * serialization without keeping mutable editor state.
  */
 export interface LicenseOfferOrderFacade {
-    createDraft(initial?: Partial<LicenseOfferOrderDraft>): LicenseOfferOrderDraft;
-    setOfferId(draft: LicenseOfferOrderDraft, value: string): LicenseOfferOrderDraft;
-    setAmount(draft: LicenseOfferOrderDraft, value: string): LicenseOfferOrderDraft;
-    setCurrency(draft: LicenseOfferOrderDraft, value: string): LicenseOfferOrderDraft;
-    setSeats(draft: LicenseOfferOrderDraft, value: number): LicenseOfferOrderDraft;
-    setPlanName(draft: LicenseOfferOrderDraft, value: string): LicenseOfferOrderDraft;
-    setSku(draft: LicenseOfferOrderDraft, value: string): LicenseOfferOrderDraft;
-    setPaymentMethod(draft: LicenseOfferOrderDraft, value: string): LicenseOfferOrderDraft;
-    setCheckoutUrl(draft: LicenseOfferOrderDraft, value: string): LicenseOfferOrderDraft;
-    setAcceptedOfferId(draft: LicenseOfferOrderDraft, value: string): LicenseOfferOrderDraft;
-    setPaymentUrl(draft: LicenseOfferOrderDraft, value: string): LicenseOfferOrderDraft;
-    setInvoiceId(draft: LicenseOfferOrderDraft, value: string): LicenseOfferOrderDraft;
-    setActivationCode(draft: LicenseOfferOrderDraft, value: string): LicenseOfferOrderDraft;
-    setBaseClaims(draft: LicenseOfferOrderDraft, claims: LicenseClaims): LicenseOfferOrderDraft;
-    buildOfferClaims(draft: LicenseOfferOrderDraft): LicenseClaims;
-    buildOrderClaims(draft: LicenseOfferOrderDraft): LicenseClaims;
+    createState(initial?: Partial<LicenseOfferOrderState>): LicenseOfferOrderState;
+    setOfferId(state: LicenseOfferOrderState, value: string): LicenseOfferOrderState;
+    setAmount(state: LicenseOfferOrderState, value: string): LicenseOfferOrderState;
+    setCurrency(state: LicenseOfferOrderState, value: string): LicenseOfferOrderState;
+    setSeats(state: LicenseOfferOrderState, value: number): LicenseOfferOrderState;
+    setPlanName(state: LicenseOfferOrderState, value: string): LicenseOfferOrderState;
+    setSku(state: LicenseOfferOrderState, value: string): LicenseOfferOrderState;
+    setPaymentMethod(state: LicenseOfferOrderState, value: string): LicenseOfferOrderState;
+    setCheckoutUrl(state: LicenseOfferOrderState, value: string): LicenseOfferOrderState;
+    setAcceptedOfferId(state: LicenseOfferOrderState, value: string): LicenseOfferOrderState;
+    setPaymentUrl(state: LicenseOfferOrderState, value: string): LicenseOfferOrderState;
+    setInvoiceId(state: LicenseOfferOrderState, value: string): LicenseOfferOrderState;
+    setActivationCode(state: LicenseOfferOrderState, value: string): LicenseOfferOrderState;
+    setBaseClaims(state: LicenseOfferOrderState, claims: LicenseClaims): LicenseOfferOrderState;
+    buildOfferClaims(state: LicenseOfferOrderState): LicenseClaims;
+    buildOrderClaims(state: LicenseOfferOrderState): LicenseClaims;
     readOfferPreviewFromResponseBody(body: unknown): LicenseOfferPreview;
     readOrderSummaryFromResponseBody(body: unknown): LicenseOrderSummary;
-    createEditor(initial?: Partial<LicenseOfferOrderDraft>): LicenseOfferOrderEditor;
+    createEditor(initial?: Partial<LicenseOfferOrderState>): LicenseOfferOrderEditor;
 }
 /**
  * Chainable editor mirroring the didactic `get/set/build/read` style used by
@@ -104,4 +104,4 @@ export declare function createLicenseOfferOrderFacade(): LicenseOfferOrderFacade
 /**
  * Creates the chainable editor shown in the 101 tests.
  */
-export declare function createLicenseOfferOrderEditor(initial?: Partial<LicenseOfferOrderDraft>): LicenseOfferOrderEditor;
+export declare function createLicenseOfferOrderEditor(initial?: Partial<LicenseOfferOrderState>): LicenseOfferOrderEditor;

package/dist/utils/license-offer-order.js

@@ -42,11 +42,11 @@ function cloneOrder(order) {
         seats: normalizeNumber(order?.seats),
     };
 }
-function patchDraft(draft, patch) {
+function patchState(state, patch) {
     return {
-        offer: patch.offer ? cloneOffer({ ...draft.offer, ...patch.offer }) : draft.offer,
-        order: patch.order ? cloneOrder({ ...draft.order, ...patch.order }) : draft.order,
-        baseClaims: patch.baseClaims ? cloneClaims(patch.baseClaims) : cloneClaims(draft.baseClaims),
+        offer: patch.offer ? cloneOffer({ ...state.offer, ...patch.offer }) : state.offer,
+        order: patch.order ? cloneOrder({ ...state.order, ...patch.order }) : state.order,
+        baseClaims: patch.baseClaims ? cloneClaims(patch.baseClaims) : cloneClaims(state.baseClaims),
     };
 }
 /**
@@ -102,80 +102,80 @@ export function readLicenseOrderSummaryFromResponseBody(body) {
     };
 }
 function createEditorFromFacade(facade, initial) {
-    let draft = facade.createDraft(initial);
+    let state = facade.createState(initial);
     const editor = {
         setOfferId(value) {
-            draft = facade.setOfferId(draft, value);
+            state = facade.setOfferId(state, value);
             return editor;
         },
         setAmount(value) {
-            draft = facade.setAmount(draft, value);
+            state = facade.setAmount(state, value);
             return editor;
         },
         setCurrency(value) {
-            draft = facade.setCurrency(draft, value);
+            state = facade.setCurrency(state, value);
             return editor;
         },
         setSeats(value) {
-            draft = facade.setSeats(draft, value);
+            state = facade.setSeats(state, value);
             return editor;
         },
         setPlanName(value) {
-            draft = facade.setPlanName(draft, value);
+            state = facade.setPlanName(state, value);
             return editor;
         },
         setSku(value) {
-            draft = facade.setSku(draft, value);
+            state = facade.setSku(state, value);
             return editor;
         },
         setPaymentMethod(value) {
-            draft = facade.setPaymentMethod(draft, value);
+            state = facade.setPaymentMethod(state, value);
             return editor;
         },
         setCheckoutUrl(value) {
-            draft = facade.setCheckoutUrl(draft, value);
+            state = facade.setCheckoutUrl(state, value);
             return editor;
         },
         setAcceptedOfferId(value) {
-            draft = facade.setAcceptedOfferId(draft, value);
+            state = facade.setAcceptedOfferId(state, value);
             return editor;
         },
         setPaymentUrl(value) {
-            draft = facade.setPaymentUrl(draft, value);
+            state = facade.setPaymentUrl(state, value);
             return editor;
         },
         setInvoiceId(value) {
-            draft = facade.setInvoiceId(draft, value);
+            state = facade.setInvoiceId(state, value);
             return editor;
         },
         setActivationCode(value) {
-            draft = facade.setActivationCode(draft, value);
+            state = facade.setActivationCode(state, value);
             return editor;
         },
         setBaseClaims(claims) {
-            draft = facade.setBaseClaims(draft, claims);
+            state = facade.setBaseClaims(state, claims);
             return editor;
         },
         getOfferPreview() {
-            return cloneOffer(draft.offer);
+            return cloneOffer(state.offer);
         },
         getOrderSummary() {
-            return cloneOrder(draft.order);
+            return cloneOrder(state.order);
         },
         buildOfferClaims() {
-            return facade.buildOfferClaims(draft);
+            return facade.buildOfferClaims(state);
         },
         buildOrderClaims() {
-            return facade.buildOrderClaims(draft);
+            return facade.buildOrderClaims(state);
         },
         readOfferPreviewFromResponseBody(body) {
             const preview = facade.readOfferPreviewFromResponseBody(body);
-            draft = patchDraft(draft, { offer: preview });
+            state = patchState(state, { offer: preview });
             return preview;
         },
         readOrderSummaryFromResponseBody(body) {
             const summary = facade.readOrderSummaryFromResponseBody(body);
-            draft = patchDraft(draft, { order: summary });
+            state = patchState(state, { order: summary });
             return summary;
         },
     };
@@ -187,61 +187,61 @@ function createEditorFromFacade(facade, initial) {
  */
 export function createLicenseOfferOrderFacade() {
     const facade = {
-        createDraft(initial = {}) {
+        createState(initial = {}) {
             return {
                 offer: cloneOffer(initial.offer),
                 order: cloneOrder(initial.order),
                 baseClaims: cloneClaims(initial.baseClaims),
             };
         },
-        setOfferId(draft, value) { return patchDraft(draft, { offer: { offerId: value } }); },
-        setAmount(draft, value) { return patchDraft(draft, { offer: { amount: value }, order: { amount: value } }); },
-        setCurrency(draft, value) { return patchDraft(draft, { offer: { currency: value }, order: { currency: value } }); },
-        setSeats(draft, value) { return patchDraft(draft, { offer: { seats: value }, order: { seats: value } }); },
-        setPlanName(draft, value) { return patchDraft(draft, { offer: { planName: value } }); },
-        setSku(draft, value) { return patchDraft(draft, { offer: { sku: value } }); },
-        setPaymentMethod(draft, value) { return patchDraft(draft, { offer: { paymentMethod: value }, order: { paymentMethod: value } }); },
-        setCheckoutUrl(draft, value) { return patchDraft(draft, { offer: { checkoutUrl: value } }); },
-        setAcceptedOfferId(draft, value) { return patchDraft(draft, { order: { acceptedOfferId: value } }); },
-        setPaymentUrl(draft, value) { return patchDraft(draft, { order: { paymentUrl: value } }); },
-        setInvoiceId(draft, value) { return patchDraft(draft, { order: { invoiceId: value } }); },
-        setActivationCode(draft, value) { return patchDraft(draft, { order: { activationCode: value } }); },
-        setBaseClaims(draft, claims) { return patchDraft(draft, { baseClaims: claims }); },
-        buildOfferClaims(draft) {
+        setOfferId(state, value) { return patchState(state, { offer: { offerId: value } }); },
+        setAmount(state, value) { return patchState(state, { offer: { amount: value }, order: { amount: value } }); },
+        setCurrency(state, value) { return patchState(state, { offer: { currency: value }, order: { currency: value } }); },
+        setSeats(state, value) { return patchState(state, { offer: { seats: value }, order: { seats: value } }); },
+        setPlanName(state, value) { return patchState(state, { offer: { planName: value } }); },
+        setSku(state, value) { return patchState(state, { offer: { sku: value } }); },
+        setPaymentMethod(state, value) { return patchState(state, { offer: { paymentMethod: value }, order: { paymentMethod: value } }); },
+        setCheckoutUrl(state, value) { return patchState(state, { offer: { checkoutUrl: value } }); },
+        setAcceptedOfferId(state, value) { return patchState(state, { order: { acceptedOfferId: value } }); },
+        setPaymentUrl(state, value) { return patchState(state, { order: { paymentUrl: value } }); },
+        setInvoiceId(state, value) { return patchState(state, { order: { invoiceId: value } }); },
+        setActivationCode(state, value) { return patchState(state, { order: { activationCode: value } }); },
+        setBaseClaims(state, claims) { return patchState(state, { baseClaims: claims }); },
+        buildOfferClaims(state) {
             const claims = {
                 '@context': LicenseClaimContext.SchemaOrg,
-                ...cloneClaims(draft.baseClaims),
+                ...cloneClaims(state.baseClaims),
             };
-            if (draft.offer.offerId)
-                claims[ClaimsOfferSchemaorg.identifier] = draft.offer.offerId;
-            if (draft.offer.amount)
-                claims[ClaimsOfferSchemaorg.price] = draft.offer.amount;
-            if (draft.offer.currency)
-                claims[ClaimsOfferSchemaorg.priceCurrency] = draft.offer.currency;
-            if (typeof draft.offer.seats === 'number')
-                claims[ClaimsOfferSchemaorg.eligibleQuantityValue] = draft.offer.seats;
-            if (draft.offer.planName)
-                claims[ClaimsOfferSchemaorg.itemOfferedName] = draft.offer.planName;
-            if (draft.offer.sku)
-                claims[ClaimsOfferSchemaorg.itemOfferedSku] = draft.offer.sku;
-            if (draft.offer.paymentMethod)
-                claims[ClaimsOfferSchemaorg.acceptedPaymentMethod] = draft.offer.paymentMethod;
-            if (draft.offer.checkoutUrl)
-                claims[ClaimsOfferSchemaorg.checkoutPageURLTemplate] = draft.offer.checkoutUrl;
+            if (state.offer.offerId)
+                claims[ClaimsOfferSchemaorg.identifier] = state.offer.offerId;
+            if (state.offer.amount)
+                claims[ClaimsOfferSchemaorg.price] = state.offer.amount;
+            if (state.offer.currency)
+                claims[ClaimsOfferSchemaorg.priceCurrency] = state.offer.currency;
+            if (typeof state.offer.seats === 'number')
+                claims[ClaimsOfferSchemaorg.eligibleQuantityValue] = state.offer.seats;
+            if (state.offer.planName)
+                claims[ClaimsOfferSchemaorg.itemOfferedName] = state.offer.planName;
+            if (state.offer.sku)
+                claims[ClaimsOfferSchemaorg.itemOfferedSku] = state.offer.sku;
+            if (state.offer.paymentMethod)
+                claims[ClaimsOfferSchemaorg.acceptedPaymentMethod] = state.offer.paymentMethod;
+            if (state.offer.checkoutUrl)
+                claims[ClaimsOfferSchemaorg.checkoutPageURLTemplate] = state.offer.checkoutUrl;
             return claims;
         },
-        buildOrderClaims(draft) {
-            const claims = facade.buildOfferClaims(draft);
-            if (draft.order.acceptedOfferId)
-                claims[ClaimsOrderSchemaorg.acceptedOfferIdentifier] = draft.order.acceptedOfferId;
-            if (draft.order.paymentUrl)
-                claims[ClaimsOrderSchemaorg.paymentUrl] = draft.order.paymentUrl;
-            if (draft.order.invoiceId)
-                claims[ClaimsOrderSchemaorg.partOfInvoice] = draft.order.invoiceId;
-            if (draft.order.paymentMethod)
-                claims[ClaimsOrderSchemaorg.paymentMethod] = draft.order.paymentMethod;
-            if (draft.order.activationCode)
-                claims[ClaimsIndividualProductSchemaorg.serialNumber] = draft.order.activationCode;
+        buildOrderClaims(state) {
+            const claims = facade.buildOfferClaims(state);
+            if (state.order.acceptedOfferId)
+                claims[ClaimsOrderSchemaorg.acceptedOfferIdentifier] = state.order.acceptedOfferId;
+            if (state.order.paymentUrl)
+                claims[ClaimsOrderSchemaorg.paymentUrl] = state.order.paymentUrl;
+            if (state.order.invoiceId)
+                claims[ClaimsOrderSchemaorg.partOfInvoice] = state.order.invoiceId;
+            if (state.order.paymentMethod)
+                claims[ClaimsOrderSchemaorg.paymentMethod] = state.order.paymentMethod;
+            if (state.order.activationCode)
+                claims[ClaimsIndividualProductSchemaorg.serialNumber] = state.order.activationCode;
             return claims;
         },
         readOfferPreviewFromResponseBody(body) { return readLicenseOfferPreviewFromResponseBody(body); },

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

@@ -0,0 +1,59 @@
+export declare const OrganizationLifecycleOperations: Readonly<{
+    readonly Enable: "enable";
+    readonly Disable: "disable";
+    readonly Purge: "purge";
+}>;
+export type OrganizationLifecycleOperation = typeof OrganizationLifecycleOperations[keyof typeof OrganizationLifecycleOperations];
+export type OrganizationLifecycleClaims = Record<string, unknown>;
+export type OrganizationLifecycleEditorState = Readonly<{
+    operation: OrganizationLifecycleOperation;
+    claims: OrganizationLifecycleClaims;
+    requestType?: string;
+    thid?: string;
+}>;
+export type OrganizationLifecycleDataEntry = Readonly<{
+    type: string;
+    request: {
+        method: 'POST';
+    };
+    meta: {
+        claims: OrganizationLifecycleClaims;
+    };
+    resource: {
+        resourceType: 'Organization';
+        meta: {
+            claims: OrganizationLifecycleClaims;
+        };
+    };
+}>;
+export type OrganizationLifecyclePayload = Readonly<{
+    thid: string;
+    body: {
+        data: OrganizationLifecycleDataEntry[];
+    };
+}>;
+export declare class OrganizationLifecycleEditor {
+    private draft;
+    constructor(initial?: Partial<OrganizationLifecycleEditorState>);
+    mergeClaims(claims: OrganizationLifecycleClaims): this;
+    setClaims(claims: OrganizationLifecycleClaims): this;
+    setContext(context: string): this;
+    setIdentifier(identifier: string): this;
+    setIdentifierValue(identifierValue: string): this;
+    setTaxId(taxId: string): this;
+    setOperation(operation: OrganizationLifecycleOperation): this;
+    setRequestType(requestType: string): this;
+    setThreadId(thid: string): this;
+    getContext(): string | undefined;
+    getIdentifier(): string | undefined;
+    getIdentifierValue(): string | undefined;
+    getTaxId(): string | undefined;
+    getOperation(): OrganizationLifecycleOperation;
+    getRequestType(): string | undefined;
+    getThreadId(): string | undefined;
+    getClaims(): OrganizationLifecycleClaims;
+    getState(): OrganizationLifecycleEditorState;
+    getEditorState(): OrganizationLifecycleEditorState;
+    buildCurrentGwDataEntry(): OrganizationLifecycleDataEntry;
+    buildCurrentGwPayload(): OrganizationLifecyclePayload;
+}

package/dist/utils/organization-lifecycle.js

@@ -0,0 +1,155 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { ClaimsOrganizationSchemaorg } from '../constants/schemaorg.js';
+export const OrganizationLifecycleOperations = Object.freeze({
+    Enable: 'enable',
+    Disable: 'disable',
+    Purge: 'purge',
+});
+function cloneClaims(claims) {
+    return { ...(claims || {}) };
+}
+function normalizeText(value) {
+    const normalized = String(value ?? '').trim();
+    return normalized || undefined;
+}
+function normalizeDraft(draft) {
+    return {
+        operation: draft?.operation || OrganizationLifecycleOperations.Disable,
+        claims: {
+            '@context': 'org.schema',
+            ...cloneClaims(draft?.claims),
+        },
+        requestType: normalizeText(draft?.requestType),
+        thid: normalizeText(draft?.thid),
+    };
+}
+function patchDraft(draft, patch) {
+    return normalizeDraft({
+        ...draft,
+        ...patch,
+        claims: patch.claims ? cloneClaims(patch.claims) : cloneClaims(draft.claims),
+    });
+}
+function createLifecycleThreadId(operation) {
+    return `organization-${operation}-example-001`;
+}
+export class OrganizationLifecycleEditor {
+    draft;
+    constructor(initial) {
+        this.draft = normalizeDraft(initial);
+    }
+    mergeClaims(claims) {
+        this.draft = patchDraft(this.draft, { claims: { ...this.draft.claims, ...cloneClaims(claims) } });
+        return this;
+    }
+    setClaims(claims) {
+        this.draft = patchDraft(this.draft, { claims });
+        return this;
+    }
+    setContext(context) {
+        this.draft = patchDraft(this.draft, {
+            claims: {
+                ...this.draft.claims,
+                '@context': String(context).trim(),
+            },
+        });
+        return this;
+    }
+    setIdentifier(identifier) {
+        this.draft = patchDraft(this.draft, {
+            claims: {
+                ...this.draft.claims,
+                [ClaimsOrganizationSchemaorg.identifier]: String(identifier).trim(),
+            },
+        });
+        return this;
+    }
+    setIdentifierValue(identifierValue) {
+        this.draft = patchDraft(this.draft, {
+            claims: {
+                ...this.draft.claims,
+                [ClaimsOrganizationSchemaorg.identifierValue]: String(identifierValue).trim(),
+            },
+        });
+        return this;
+    }
+    setTaxId(taxId) {
+        this.draft = patchDraft(this.draft, {
+            claims: {
+                ...this.draft.claims,
+                [ClaimsOrganizationSchemaorg.taxId]: String(taxId).trim(),
+            },
+        });
+        return this;
+    }
+    setOperation(operation) {
+        this.draft = patchDraft(this.draft, { operation });
+        return this;
+    }
+    setRequestType(requestType) {
+        this.draft = patchDraft(this.draft, { requestType });
+        return this;
+    }
+    setThreadId(thid) {
+        this.draft = patchDraft(this.draft, { thid });
+        return this;
+    }
+    getContext() {
+        return normalizeText(this.draft.claims['@context']) || undefined;
+    }
+    getIdentifier() {
+        return normalizeText(this.draft.claims[ClaimsOrganizationSchemaorg.identifier]) || undefined;
+    }
+    getIdentifierValue() {
+        return normalizeText(this.draft.claims[ClaimsOrganizationSchemaorg.identifierValue]) || undefined;
+    }
+    getTaxId() {
+        return normalizeText(this.draft.claims[ClaimsOrganizationSchemaorg.taxId]) || undefined;
+    }
+    getOperation() {
+        return this.draft.operation;
+    }
+    getRequestType() {
+        return normalizeText(this.draft.requestType) || undefined;
+    }
+    getThreadId() {
+        return normalizeText(this.draft.thid) || undefined;
+    }
+    getClaims() {
+        return cloneClaims(this.draft.claims);
+    }
+    getState() {
+        return normalizeDraft(this.draft);
+    }
+    getEditorState() {
+        return this.getState();
+    }
+    buildCurrentGwDataEntry() {
+        const requestType = normalizeText(this.draft.requestType);
+        if (!requestType) {
+            throw new Error('OrganizationLifecycleEditor.buildCurrentGwDataEntry requires requestType.');
+        }
+        const claims = this.getClaims();
+        return {
+            type: requestType,
+            request: { method: 'POST' },
+            meta: { claims },
+            resource: {
+                resourceType: 'Organization',
+                meta: { claims },
+            },
+        };
+    }
+    buildCurrentGwPayload() {
+        const requestType = normalizeText(this.draft.requestType);
+        if (!requestType) {
+            throw new Error('OrganizationLifecycleEditor.buildCurrentGwPayload requires requestType.');
+        }
+        return {
+            thid: this.draft.thid || createLifecycleThreadId(this.draft.operation),
+            body: {
+                data: [this.buildCurrentGwDataEntry()],
+            },
+        };
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdc-common-utils-ts",
-  "version": "1.24.3",
+  "version": "2.0.2",
   "publishConfig": {
     "access": "public"
   },
@@ -10,7 +10,7 @@
     "@stablelib/base64": "^1.0.1",
     "@stablelib/utf8": "^1.0.2",
     "base-x": "^4.0.0",
-    "gdc-common-utils-ts": "^1.24.0",
+    "gdc-common-utils-ts": "^2.0.1",
     "pako": "^2.1.0"
   },
   "scripts": {