gdc-common-utils-ts 1.4.15 → 1.4.17

package/dist/utils/activation-policy.d.ts

@@ -0,0 +1,20 @@
+export type ActivationRepresentativePolicyErrorCode = 'MISSING_REPRESENTATIVE_DID_WEB' | 'MISSING_REPRESENTATIVE_ROLE_RESPRSN' | 'MISSING_REPRESENTATIVE_CREDENTIAL_MATERIAL' | 'REPRESENTATIVE_TAXID_MISMATCH';
+export type ActivationRepresentativePolicyError = {
+    code: ActivationRepresentativePolicyErrorCode;
+    message: string;
+};
+export declare function extractCredentialSubject(credential: unknown): Record<string, unknown> | undefined;
+export declare function normalizeTaxIdentifier(value: unknown): string | undefined;
+export declare function extractOrganizationTaxId(organizationCredential: unknown): string | undefined;
+export declare function extractRepresentativeMemberOfTaxId(representativeCredential: unknown): string | undefined;
+export declare function extractRepresentativeRoleCode(representativeCredential: unknown): string | undefined;
+export declare function hasRoleCode(roleCode: string | undefined, requiredCode?: string): boolean;
+export declare function extractRepresentativeCredentialMaterial(representativeCredential: unknown): string | undefined;
+export declare function extractDidWebFromCredential(credential: unknown): string | undefined;
+export declare function buildMemberDidWeb(ownerDidWeb: string, memberId: string, roleCode: string): string;
+export declare function isMemberDidWebUnderOwner(memberDidWeb: string, ownerDidWeb: string): boolean;
+export declare function validateActivationRepresentativePolicy(input: {
+    organizationCredential?: unknown;
+    representativeCredential?: unknown;
+    requiredRoleCode?: string;
+}): ActivationRepresentativePolicyError[];

package/dist/utils/activation-policy.js

@@ -0,0 +1,130 @@
+function asObject(value) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    return value;
+}
+export function extractCredentialSubject(credential) {
+    const obj = asObject(credential);
+    if (!obj)
+        return undefined;
+    const subject = obj.credentialSubject;
+    if (Array.isArray(subject))
+        return asObject(subject[0]);
+    return asObject(subject);
+}
+export function normalizeTaxIdentifier(value) {
+    const normalized = String(value || '').trim().toUpperCase();
+    return normalized || undefined;
+}
+export function extractOrganizationTaxId(organizationCredential) {
+    const subject = extractCredentialSubject(organizationCredential) || {};
+    const identifier = asObject(subject.identifier);
+    return (normalizeTaxIdentifier(subject.taxID)
+        || normalizeTaxIdentifier(subject.taxId)
+        || normalizeTaxIdentifier(identifier?.value)
+        || normalizeTaxIdentifier(subject.identifierValue));
+}
+export function extractRepresentativeMemberOfTaxId(representativeCredential) {
+    const subject = extractCredentialSubject(representativeCredential) || {};
+    const memberOf = asObject(subject.memberOf) || {};
+    const identifier = asObject(memberOf.identifier);
+    return (normalizeTaxIdentifier(memberOf.taxID)
+        || normalizeTaxIdentifier(memberOf.taxId)
+        || normalizeTaxIdentifier(identifier?.value)
+        || normalizeTaxIdentifier(memberOf.identifierValue));
+}
+export function extractRepresentativeRoleCode(representativeCredential) {
+    const subject = extractCredentialSubject(representativeCredential) || {};
+    const occupation = subject.hasOccupation;
+    if (typeof occupation === 'string')
+        return occupation.trim() || undefined;
+    if (occupation && typeof occupation === 'object') {
+        const occ = occupation;
+        const id = String(occ.identifier || '').trim();
+        if (id)
+            return id;
+        const name = String(occ.name || '').trim();
+        if (name)
+            return name;
+    }
+    return undefined;
+}
+export function hasRoleCode(roleCode, requiredCode = 'RESPRSN') {
+    const normalizedRole = String(roleCode || '').trim().toUpperCase();
+    const normalizedRequired = String(requiredCode || '').trim().toUpperCase();
+    return normalizedRole.includes(normalizedRequired);
+}
+export function extractRepresentativeCredentialMaterial(representativeCredential) {
+    const subject = extractCredentialSubject(representativeCredential) || {};
+    const credentialData = subject.hasCredential;
+    if (typeof credentialData === 'string')
+        return credentialData.trim() || undefined;
+    if (Array.isArray(credentialData)) {
+        for (const item of credentialData) {
+            const mat = String(item?.material || '').trim();
+            if (mat)
+                return mat;
+        }
+    }
+    if (credentialData && typeof credentialData === 'object') {
+        const mat = String(credentialData?.material || '').trim();
+        if (mat)
+            return mat;
+    }
+    return undefined;
+}
+export function extractDidWebFromCredential(credential) {
+    const obj = asObject(credential);
+    if (!obj)
+        return undefined;
+    const subject = extractCredentialSubject(obj);
+    const didCandidate = String(subject?.id || obj.id || '').trim();
+    return didCandidate.startsWith('did:web:') ? didCandidate : undefined;
+}
+export function buildMemberDidWeb(ownerDidWeb, memberId, roleCode) {
+    return `${String(ownerDidWeb).trim()}:member:${String(memberId).trim()}:${String(roleCode).trim()}`;
+}
+export function isMemberDidWebUnderOwner(memberDidWeb, ownerDidWeb) {
+    const did = String(memberDidWeb || '').trim();
+    const owner = String(ownerDidWeb || '').trim();
+    if (!did.startsWith('did:web:') || !owner.startsWith('did:web:'))
+        return false;
+    return did.startsWith(`${owner}:member:`);
+}
+export function validateActivationRepresentativePolicy(input) {
+    const errors = [];
+    const representativeDid = input.representativeCredential
+        ? extractDidWebFromCredential(input.representativeCredential)
+        : undefined;
+    if (input.representativeCredential && !representativeDid) {
+        errors.push({
+            code: 'MISSING_REPRESENTATIVE_DID_WEB',
+            message: 'ICA-issued representative credential is missing credentialSubject.id did:web.',
+        });
+    }
+    if (!input.representativeCredential)
+        return errors;
+    const orgTax = extractOrganizationTaxId(input.organizationCredential);
+    const repTax = extractRepresentativeMemberOfTaxId(input.representativeCredential);
+    if (orgTax && repTax && orgTax !== repTax) {
+        errors.push({
+            code: 'REPRESENTATIVE_TAXID_MISMATCH',
+            message: 'ICA-issued representative credential memberOf.taxID must match organization credential taxID.',
+        });
+    }
+    const roleCode = extractRepresentativeRoleCode(input.representativeCredential);
+    if (!hasRoleCode(roleCode, input.requiredRoleCode || 'RESPRSN')) {
+        errors.push({
+            code: 'MISSING_REPRESENTATIVE_ROLE_RESPRSN',
+            message: 'ICA-issued representative credential must include Responsible Party role (RESPRSN) in credentialSubject.hasOccupation.',
+        });
+    }
+    const material = extractRepresentativeCredentialMaterial(input.representativeCredential);
+    if (!material) {
+        errors.push({
+            code: 'MISSING_REPRESENTATIVE_CREDENTIAL_MATERIAL',
+            message: 'ICA-issued representative credential is missing credentialSubject.hasCredential.material.',
+        });
+    }
+    return errors;
+}

package/dist/utils/index.d.ts

@@ -1,4 +1,5 @@
 export * from './actor';
+export * from './activation-policy';
 export * from './base-convert';
 export * from './baseN';
 export * from './bundle';

package/dist/utils/index.js

@@ -1,4 +1,5 @@
 export * from './actor.js';
+export * from './activation-policy.js';
 export * from './base-convert.js';
 export * from './baseN.js';
 export * from './bundle.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdc-common-utils-ts",
-  "version": "1.4.15",
+  "version": "1.4.17",
   "publishConfig": {
     "access": "public"
   },