gdc-common-utils-ts 1.24.1 → 2.0.1

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/dist/utils/same-as.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Builds the ICA-compatible multibase58(multihash(sha3-256)) payload for a
+ * public controller alias.
+ *
+ * Synchronization note:
+ * - this helper is intentionally copied from the current ICA-side algorithm in
+ *   `dataspace-ica-ts/src/api/tools/multihash.ts`
+ * - do not change this hashing/normalization contract here without updating
+ *   the ICA implementation in lockstep
+ *
+ * @param value Raw canonical string to hash.
+ */
+export declare function multibase58MultihashSha3_256(value: string): string;
+/**
+ * Normalizes a public controller alias into the same representation used by
+ * ICA for `credentialSubject.sameAs` and `controller.sameAs`.
+ *
+ * Synchronization note:
+ * - this helper is a copied shared version of the current ICA algorithm from
+ *   `dataspace-ica-ts/src/api/tools/multihash.ts`
+ * - it exists in `gdc-common-utils-ts` so BFF/backend callers can compute the
+ *   exact same value before calling GW/ICA
+ * - do not let the two implementations drift
+ *
+ * Current rules:
+ * - `urn:multibase:z...` stays unchanged
+ * - bare `z...` becomes `urn:multibase:z...`
+ * - plain email becomes hashed `urn:multibase:z...`
+ * - any other identifier (for example `tel:+...`, `did:web:...`, custom URN)
+ *   stays unchanged
+ *
+ * @param value Email, phone, DID, URN, or any other public alias string.
+ */
+export declare function normalizeSameAsHash(value: string): string;
+/**
+ * Compares two public controller aliases after ICA-compatible normalization.
+ *
+ * @param left First alias.
+ * @param right Second alias.
+ */
+export declare function sameAsValuesEqual(left: string, right: string): boolean;

package/dist/utils/same-as.js

@@ -0,0 +1,83 @@
+import { createHash } from 'crypto';
+import { encodeMultibase58btc } from './multibase58.js';
+/**
+ * Builds the ICA-compatible multibase58(multihash(sha3-256)) payload for a
+ * public controller alias.
+ *
+ * Synchronization note:
+ * - this helper is intentionally copied from the current ICA-side algorithm in
+ *   `dataspace-ica-ts/src/api/tools/multihash.ts`
+ * - do not change this hashing/normalization contract here without updating
+ *   the ICA implementation in lockstep
+ *
+ * @param value Raw canonical string to hash.
+ */
+export function multibase58MultihashSha3_256(value) {
+    const normalized = value.trim();
+    if (!normalized) {
+        throw new Error('Cannot create multihash from empty value.');
+    }
+    const digest = createHash('sha3-256').update(normalized, 'utf8').digest();
+    const multihash = Buffer.concat([Buffer.from([0x16, 0x20]), digest]);
+    return encodeMultibase58btc(multihash);
+}
+function looksLikeBase58Multibase(value) {
+    return /^z\S+$/.test(value.trim());
+}
+function looksLikeEmail(value) {
+    const trimmed = value.trim();
+    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(trimmed);
+}
+/**
+ * Normalizes a public controller alias into the same representation used by
+ * ICA for `credentialSubject.sameAs` and `controller.sameAs`.
+ *
+ * Synchronization note:
+ * - this helper is a copied shared version of the current ICA algorithm from
+ *   `dataspace-ica-ts/src/api/tools/multihash.ts`
+ * - it exists in `gdc-common-utils-ts` so BFF/backend callers can compute the
+ *   exact same value before calling GW/ICA
+ * - do not let the two implementations drift
+ *
+ * Current rules:
+ * - `urn:multibase:z...` stays unchanged
+ * - bare `z...` becomes `urn:multibase:z...`
+ * - plain email becomes hashed `urn:multibase:z...`
+ * - any other identifier (for example `tel:+...`, `did:web:...`, custom URN)
+ *   stays unchanged
+ *
+ * @param value Email, phone, DID, URN, or any other public alias string.
+ */
+export function normalizeSameAsHash(value) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return '';
+    if (trimmed.toLowerCase().startsWith('urn:multibase:')) {
+        const suffix = trimmed.slice('urn:multibase:'.length).trim();
+        return looksLikeBase58Multibase(suffix) ? `urn:multibase:${suffix}` : trimmed;
+    }
+    if (looksLikeBase58Multibase(trimmed)) {
+        return `urn:multibase:${trimmed}`;
+    }
+    if (looksLikeEmail(trimmed)) {
+        return `urn:multibase:${multibase58MultihashSha3_256(trimmed.toLowerCase())}`;
+    }
+    return trimmed;
+}
+/**
+ * Compares two public controller aliases after ICA-compatible normalization.
+ *
+ * @param left First alias.
+ * @param right Second alias.
+ */
+export function sameAsValuesEqual(left, right) {
+    const normalizeComparable = (value) => {
+        const normalized = normalizeSameAsHash(value);
+        return normalized.toLowerCase().startsWith('urn:multibase:')
+            ? normalized.slice('urn:multibase:'.length)
+            : normalized;
+    };
+    const normalizedLeft = normalizeComparable(left);
+    const normalizedRight = normalizeComparable(right);
+    return !!normalizedLeft && normalizedLeft === normalizedRight;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdc-common-utils-ts",
-  "version": "1.24.1",
+  "version": "2.0.1",
   "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": {