gdc-sdk-front-ts 0.6.2 → 0.6.6

package/dist/gdc-common-utils-ts/src/utils/activation-request.js

@@ -0,0 +1,99 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+function pushIssue(issues, severity, code, message, path) {
+    issues.push({ severity, code, message, ...(path ? { path } : {}) });
+}
+function normalizeJwkSet(publicKeys) {
+    if (!publicKeys) {
+        return undefined;
+    }
+    if (Array.isArray(publicKeys)) {
+        return { keys: publicKeys };
+    }
+    return publicKeys;
+}
+/**
+ * Builds the canonical controller/person binding from semantic variables.
+ *
+ * Use this when your integration starts from variables such as:
+ * - `controllerDid`
+ * - `controllerEmail` converted to `sameAs`
+ * - `publicSignKey`
+ * - `publicKeys`
+ *
+ * so the caller does not have to manually shape `controller.publicKeyJwk` and
+ * `controller.jwks`.
+ */
+export function buildControllerBindingInput(input) {
+    const jwks = normalizeJwkSet(input.publicKeys);
+    return {
+        ...(input.did ? { did: input.did } : {}),
+        ...(input.sameAs ? { sameAs: input.sameAs } : {}),
+        ...(input.publicSignKey ? { publicKeyJwk: input.publicSignKey } : {}),
+        ...(jwks ? { jwks } : {}),
+    };
+}
+/**
+ * Builds the canonical organization/provider binding from semantic variables.
+ */
+export function buildOrganizationBindingInput(input) {
+    const jwks = normalizeJwkSet(input.publicKeys);
+    return {
+        ...(input.did ? { did: input.did } : {}),
+        ...(input.url ? { url: input.url } : {}),
+        ...(input.publicSignKey ? { publicKeyJwk: input.publicSignKey } : {}),
+        ...(jwks ? { jwks } : {}),
+    };
+}
+/**
+ * Builds the canonical `_activate` request payload shared by SDK and GW helpers.
+ *
+ * The resulting object intentionally preserves deprecated compatibility fields
+ * when supplied, so callers can keep legacy flows alive while validators and
+ * runtime layers flag that debt explicitly.
+ */
+export function buildOrganizationActivationRequest(input) {
+    return {
+        vp_token: input.vpToken,
+        ...(input.presentationSubmission ? { presentation_submission: input.presentationSubmission } : {}),
+        ...(input.controller ? { controller: input.controller } : {}),
+        ...(input.organization ? { organization: input.organization } : {}),
+        ...(input.data ? { data: input.data } : {}),
+        ...(input.organizationCredential !== undefined ? { organizationCredential: input.organizationCredential } : {}),
+        ...(input.representativeCredential !== undefined ? { representativeCredential: input.representativeCredential } : {}),
+    };
+}
+/**
+ * Validates the canonical activation request contract.
+ *
+ * Priority rules:
+ * 1. `vp_token` is mandatory as the canonical activation proof.
+ * 2. `controller.*` is optional, but if a controller DID/alias is provided then
+ *    matching public key material must also be present so a DID Document can be published.
+ * 3. Legacy `organizationCredential` and `representativeCredential` are tolerated
+ *    only as deprecated compatibility inputs and therefore produce warnings.
+ */
+export function validateOrganizationActivationRequest(request) {
+    const issues = [];
+    if (!String(request.vp_token || '').trim()) {
+        pushIssue(issues, 'error', 'missing-vp-token', 'Canonical activation proof must be carried in vp_token.', 'vp_token');
+    }
+    if (request.organizationCredential !== undefined) {
+        pushIssue(issues, 'warning', 'deprecated-organization-credential', 'organizationCredential is deprecated compatibility input. Canonical proof must be carried in vp_token.', 'organizationCredential');
+    }
+    if (request.representativeCredential !== undefined) {
+        pushIssue(issues, 'warning', 'deprecated-representative-credential', 'representativeCredential is deprecated compatibility input. Canonical proof must be carried in vp_token.', 'representativeCredential');
+    }
+    const controller = request.controller;
+    if (controller) {
+        const hasPublicKeyJwk = !!controller.publicKeyJwk;
+        const hasJwks = !!controller.jwks?.keys?.length;
+        if ((controller.did || controller.sameAs) && !(hasPublicKeyJwk || hasJwks)) {
+            pushIssue(issues, 'error', 'incomplete-controller-binding', 'controller.did/controller.sameAs requires controller.publicKeyJwk or controller.jwks for DID bootstrap.', 'controller');
+        }
+    }
+    return {
+        ok: !issues.some((issue) => issue.severity === 'error'),
+        errors: issues.filter((issue) => issue.severity === 'error'),
+        warnings: issues.filter((issue) => issue.severity === 'warning'),
+    };
+}

package/dist/gdc-common-utils-ts/src/utils/actor.d.ts

@@ -0,0 +1,18 @@
+export type ParsedActor = {
+    /**
+     * The token subject / authenticated actor identifier (as provided in the token request).
+     * Examples:
+     * - did:web:api.acme.org:employee:doctor1@acme.org:ISCO-08|2211
+     * - did:web:api.acme.org:employee:doctor1@acme.org:ISCO-08|2211:<device-uuid>
+     * - did:web:api.acme.org:family:<id>:v3-RoleCode|ONESELF
+     * - did:web:api.acme.org:family:<id>:v3-RoleCode|CHILD:<device-uuid>
+     */
+    sub: string;
+    /** The actor identifier (employee email, familyId, or raw email). */
+    identifier?: string;
+    /** The employee role code if present (e.g. "ISCO-08|2211"). */
+    role?: string;
+    /** The base organization did:web if `sub` is did:web (e.g. "did:web:api.acme.org"). */
+    organization?: string;
+};
+export declare function parseActorFromSub(sub: string): ParsedActor;

package/dist/gdc-common-utils-ts/src/utils/actor.js

@@ -0,0 +1,36 @@
+// src/utils/actor.ts
+export function parseActorFromSub(sub) {
+    const trimmed = (sub || '').trim();
+    const parsed = { sub: trimmed };
+    if (!trimmed)
+        return parsed;
+    if (trimmed.startsWith('did:web:')) {
+        // Base org DID is always the first component after did:web:
+        // did:web:<host>[:...]
+        const after = trimmed.replace(/^did:web:/, '');
+        const host = after.split(':')[0];
+        if (host)
+            parsed.organization = `did:web:${host}`;
+        // Extract email and role from endpoint-style DID shapes:
+        // did:web:<host>:(employee|family):<id>:<roleSystem>|<roleCode>[:<uuid>]
+        const parts = after.split(':');
+        const employeeIdx = parts.indexOf('employee');
+        const familyIdx = parts.indexOf('family');
+        const idIdx = employeeIdx >= 0 ? employeeIdx + 1 : familyIdx >= 0 ? familyIdx + 1 : -1;
+        const identifier = idIdx >= 0 ? parts[idIdx] : undefined;
+        if (identifier) {
+            parsed.identifier = identifier.includes('@') ? identifier.toLowerCase() : identifier;
+        }
+        if (idIdx >= 0 && parts.length > idIdx + 1) {
+            const roleCandidate = parts[idIdx + 1];
+            if (roleCandidate && roleCandidate.includes('|'))
+                parsed.role = roleCandidate;
+        }
+        return parsed;
+    }
+    // Raw email actor identifier
+    if (trimmed.includes('@') && !/\s/.test(trimmed)) {
+        parsed.identifier = trimmed.toLowerCase();
+    }
+    return parsed;
+}

package/dist/gdc-common-utils-ts/src/utils/base-convert.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Converts a `Uint8Array` into a hexadecimal string.
+ *
+ * @param bytes Raw bytes to encode.
+ */
+export declare function bytesToHexString(bytes: Uint8Array): string;
+/**
+ * Encodes a `Uint8Array` into a Base58 string.
+ *
+ * @param bytes Raw bytes to encode.
+ */
+export declare function bytesToBase58(bytes: Uint8Array): string;
+/**
+ * Decodes a Base58 string into a `Uint8Array`.
+ *
+ * @param base58str Base58 string to decode.
+ */
+export declare function base58ToBytes(base58str: string): Uint8Array;
+/**
+ * Encodes a string into a standard Base64 string with padding.
+ *
+ * @param str UTF-8 string to encode.
+ */
+export declare function stringToStdBase64(str: string): string;
+/**
+ * Converts a standard Base64 string into a Base64URL string.
+ *
+ * @param encodedData Standard Base64 string.
+ */
+export declare function base64ToBase64Url(encodedData: string): string;
+/**
+ * Encodes a string into a Base64URL string.
+ *
+ * @param stringifiedData UTF-8 string to encode.
+ */
+export declare function stringToBase64Url(stringifiedData: string): string;
+/**
+ * Converts a Base64URL string into a standard Base64 string.
+ *
+ * @param encodedData Base64URL string.
+ */
+export declare function base64UrlToBase64(encodedData: string): string;
+/**
+ * Decodes a string that is either Base64 or Base64URL into a `Uint8Array`.
+ *
+ * @param base64OrUrlSafe Base64 or Base64URL string.
+ */
+export declare function base64OrUrlSafeToBytes(base64OrUrlSafe: string): Uint8Array;
+/**
+ * Encodes a `Uint8Array` into a standard Base64 string with padding.
+ *
+ * @param bytes Raw bytes to encode.
+ */
+export declare function bytesToBase64(bytes: Uint8Array): string;
+/**
+ * Encodes a `Uint8Array` into a raw Base64URL string without padding.
+ *
+ * @param bytes Raw bytes to encode.
+ */
+export declare function bytesToRawBase64UrlSafe(bytes: Uint8Array): string;

package/dist/gdc-common-utils-ts/src/utils/base-convert.js

@@ -0,0 +1,104 @@
+// crypto-ts/utils/base-convert.ts
+import { encode as encodeBase64, decode as decodeBase64, decodeURLSafe, encodeURLSafe, } from "@stablelib/base64";
+import { alphabetBase58, decodeN, encodeN } from './baseN';
+import { stringToBytesUTF8 } from './string-convert';
+/**
+ * Converts a `Uint8Array` into a hexadecimal string.
+ *
+ * @param bytes Raw bytes to encode.
+ */
+export function bytesToHexString(bytes) {
+    return Array.from(bytes, (byte) => {
+        return ('0' + (byte & 0xff).toString(16)).slice(-2);
+    }).join('');
+}
+;
+/**
+ * Encodes a `Uint8Array` into a Base58 string.
+ *
+ * @param bytes Raw bytes to encode.
+ */
+export function bytesToBase58(bytes) {
+    return encodeN(bytes, alphabetBase58, undefined);
+}
+/**
+ * Decodes a Base58 string into a `Uint8Array`.
+ *
+ * @param base58str Base58 string to decode.
+ */
+export function base58ToBytes(base58str) {
+    return decodeN(base58str, alphabetBase58);
+}
+/**
+ * Encodes a string into a standard Base64 string with padding.
+ *
+ * @param str UTF-8 string to encode.
+ */
+export function stringToStdBase64(str) {
+    const dataBytes = stringToBytesUTF8(str);
+    return encodeBase64(dataBytes);
+}
+/**
+ * Converts a standard Base64 string into a Base64URL string.
+ *
+ * @param encodedData Standard Base64 string.
+ */
+export function base64ToBase64Url(encodedData) {
+    if (encodedData && (encodedData.indexOf("+") !== -1 || encodedData.indexOf("/") !== -1)) {
+        return encodedData.split("+").join("-").split("/").join("_");
+    }
+    else {
+        return encodedData;
+    }
+}
+/**
+ * Encodes a string into a Base64URL string.
+ *
+ * @param stringifiedData UTF-8 string to encode.
+ */
+export function stringToBase64Url(stringifiedData) {
+    const encodedData = stringToStdBase64(stringifiedData);
+    return base64ToBase64Url(encodedData);
+}
+/**
+ * Converts a Base64URL string into a standard Base64 string.
+ *
+ * @param encodedData Base64URL string.
+ */
+export function base64UrlToBase64(encodedData) {
+    if (encodedData && (encodedData.indexOf("-") !== -1 || encodedData.indexOf("_") !== -1)) {
+        return encodedData.split("-").join("+").split("_").join("/");
+    }
+    else {
+        return encodedData;
+    }
+}
+/**
+ * Decodes a string that is either Base64 or Base64URL into a `Uint8Array`.
+ *
+ * @param base64OrUrlSafe Base64 or Base64URL string.
+ */
+export function base64OrUrlSafeToBytes(base64OrUrlSafe) {
+    if (String(base64OrUrlSafe).includes("+") || String(base64OrUrlSafe).includes("/")) {
+        return new Uint8Array(decodeBase64(base64OrUrlSafe));
+    }
+    else {
+        return new Uint8Array(decodeURLSafe(base64OrUrlSafe));
+    }
+}
+/**
+ * Encodes a `Uint8Array` into a standard Base64 string with padding.
+ *
+ * @param bytes Raw bytes to encode.
+ */
+export function bytesToBase64(bytes) {
+    return encodeBase64(bytes);
+}
+/**
+ * Encodes a `Uint8Array` into a raw Base64URL string without padding.
+ *
+ * @param bytes Raw bytes to encode.
+ */
+export function bytesToRawBase64UrlSafe(bytes) {
+    return encodeURLSafe(bytes).replace(/=/g, "");
+}

package/dist/gdc-common-utils-ts/src/utils/baseN.d.ts

@@ -0,0 +1,35 @@
+export declare const alphabetBase58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+export declare class BaseN {
+    constructor();
+    /** BaseN-encodes a Uint8Array using the given alphabet */
+    static encodeN(input: Uint8Array, alphabet: string, maxline: string | undefined): string;
+    /** Decodes a baseN-encoded (using the given alphabet) string to a Uint8Array. */
+    static decodeN(input: string, alphabet: string): Uint8Array;
+    /** Base58-encodes a Uint8Array using the Bitcoin alphabet '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz' */
+    static encodeBytesToBase58(inputBytes: Uint8Array): string;
+    /** Base58-encodes a Uint8Array using the Bitcoin alphabet '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz' */
+    static encodeStrToBase58(inputStr: string): string;
+    /** Decodes a base58-encoded string to a Uint8Array (using the Bitcoin alphabet '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz') */
+    static decodeBytesFromBase58(base58Str: string): Uint8Array;
+    /** Decodes a base58-encoded string to a Uint8Array (using the Bitcoin alphabet '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz') */
+    static decodeStrFromBase58(base58Str: string): string;
+}
+/**
+  * BaseN-encodes a Uint8Array using the given alphabet.
+  *
+  * @param {Uint8Array} input the bytes to encode in a Uint8Array.
+  * @param {number} maxline the maximum number of encoded characters per line to
+  *          use, defaults to none.
+  *
+  * @return {string} the baseN-encoded output string.
+  */
+export declare function encodeN(input: Uint8Array, alphabet: string, maxline: string | undefined): string;
+/**
+  * Decodes a baseN-encoded (using the given alphabet) string to a
+  * Uint8Array.
+  *
+  * @param {string} input the baseN-encoded input string.
+  *
+  * @return {Uint8Array} the decoded bytes in a Uint8Array.
+  */
+export declare function decodeN(input: string, alphabet: string): Uint8Array;

package/dist/gdc-common-utils-ts/src/utils/baseN.js

@@ -0,0 +1,174 @@
+/**
+ * From https://raw.githubusercontent.com/digitalbazaar/base58-universal/master/baseN.js
+ * Base-N/Base-X encoding/decoding functions.
+ *
+ * Original implementation from base-x:
+ * https://github.com/cryptocoinjs/base-x
+ *
+ * Which is MIT licensed:
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright base-x contributors (c) 2016
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+'use strict';
+import { bytesToStringUTF8, stringToBytesUTF8 } from './string-convert';
+// baseN alphabet indexes
+const _reverseAlphabets = [];
+// base58 characters (Bitcoin alphabet)
+export const alphabetBase58 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+export class BaseN {
+    constructor() { }
+    /** BaseN-encodes a Uint8Array using the given alphabet */
+    static encodeN(input, alphabet, maxline) {
+        return encodeN(input, alphabet, maxline);
+    }
+    /** Decodes a baseN-encoded (using the given alphabet) string to a Uint8Array. */
+    static decodeN(input, alphabet) {
+        return decodeN(input, alphabet);
+    }
+    /** Base58-encodes a Uint8Array using the Bitcoin alphabet '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz' */
+    static encodeBytesToBase58(inputBytes) {
+        return encodeN(inputBytes, alphabetBase58, undefined);
+    }
+    /** Base58-encodes a Uint8Array using the Bitcoin alphabet '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz' */
+    static encodeStrToBase58(inputStr) {
+        const inputBytes = stringToBytesUTF8(inputStr);
+        return this.encodeBytesToBase58(inputBytes);
+    }
+    /** Decodes a base58-encoded string to a Uint8Array (using the Bitcoin alphabet '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz') */
+    static decodeBytesFromBase58(base58Str) {
+        return decodeN(base58Str, alphabetBase58);
+    }
+    /** Decodes a base58-encoded string to a Uint8Array (using the Bitcoin alphabet '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz') */
+    static decodeStrFromBase58(base58Str) {
+        const inputBytes = this.decodeBytesFromBase58(base58Str);
+        return bytesToStringUTF8(inputBytes);
+    }
+}
+/**
+  * BaseN-encodes a Uint8Array using the given alphabet.
+  *
+  * @param {Uint8Array} input the bytes to encode in a Uint8Array.
+  * @param {number} maxline the maximum number of encoded characters per line to
+  *          use, defaults to none.
+  *
+  * @return {string} the baseN-encoded output string.
+  */
+export function encodeN(input, alphabet, maxline) {
+    if (!(input instanceof Uint8Array)) {
+        throw new TypeError('"input" must be a Uint8Array.');
+    }
+    if (typeof alphabet !== 'string') {
+        throw new TypeError('"alphabet" must be a string.');
+    }
+    if (maxline !== undefined && typeof maxline !== 'number') {
+        throw new TypeError('"maxline" must be a number.');
+    }
+    if (input.length === 0) {
+        return '';
+    }
+    let output = '';
+    let i = 0;
+    const base = alphabet.length;
+    const first = alphabet.charAt(0);
+    const digits = [0];
+    for (i = 0; i < input.length; ++i) {
+        let carry = input[i];
+        for (let j = 0; j < digits.length; ++j) {
+            carry += digits[j] << 8;
+            digits[j] = carry % base;
+            carry = (carry / base) | 0;
+        }
+        while (carry > 0) {
+            digits.push(carry % base);
+            carry = (carry / base) | 0;
+        }
+    }
+    // deal with leading zeros
+    for (i = 0; input[i] === 0 && i < input.length - 1; ++i) {
+        output += first;
+    }
+    // convert digits to a string
+    for (i = digits.length - 1; i >= 0; --i) {
+        output += alphabet[digits[i]];
+    }
+    if (maxline) {
+        const match = output.match(new RegExp('.{1,' + maxline + '}', 'g'));
+        if (match) {
+            output = match.join('\r\n');
+        }
+    }
+    return output;
+}
+/**
+  * Decodes a baseN-encoded (using the given alphabet) string to a
+  * Uint8Array.
+  *
+  * @param {string} input the baseN-encoded input string.
+  *
+  * @return {Uint8Array} the decoded bytes in a Uint8Array.
+  */
+export function decodeN(input, alphabet) {
+    if (typeof input !== 'string') {
+        throw new TypeError('"input" must be a string.');
+    }
+    if (typeof alphabet !== 'string') {
+        throw new TypeError('"alphabet" must be a string.');
+    }
+    if (input.length === 0) {
+        return new Uint8Array(0);
+    }
+    let table = _reverseAlphabets[alphabet];
+    if (!table) {
+        // compute reverse alphabet
+        table = _reverseAlphabets[alphabet] = [];
+        for (let i = 0; i < alphabet.length; ++i) {
+            table[alphabet.charCodeAt(i)] = i;
+        }
+    }
+    // remove whitespace characters
+    input = input.replace(/\s/g, '');
+    const base = alphabet.length;
+    const first = alphabet.charAt(0);
+    const bytes = [0];
+    for (let i = 0; i < input.length; i++) {
+        const value = table[input.charCodeAt(i)];
+        if (value === undefined) {
+            return new Uint8Array(0); // empty
+        }
+        let carry = value;
+        for (let j = 0; j < bytes.length; ++j) {
+            carry += bytes[j] * base;
+            bytes[j] = carry & 0xff;
+            carry >>= 8;
+        }
+        while (carry > 0) {
+            bytes.push(carry & 0xff);
+            carry >>= 8;
+        }
+    }
+    // deal with leading zeros
+    for (let k = 0; input[k] === first && k < input.length - 1; ++k) {
+        bytes.push(0);
+    }
+    return new Uint8Array(bytes.reverse());
+}

package/dist/gdc-common-utils-ts/src/utils/bundle-query.d.ts

@@ -0,0 +1,35 @@
+import type { BundleEntry, BundleJsonApi } from '../models/bundle.js';
+export type BundleResourceIdFilters = Readonly<{
+    sections?: string | readonly string[];
+    resourceTypes?: string | readonly string[];
+    dateFrom?: string;
+    dateTo?: string;
+}>;
+/**
+ * Generic bundle query helper for reusable entry filtering and lookup.
+ *
+ * This utility is intentionally communication-agnostic and can be reused by
+ * any package that works with BundleJsonApi payloads.
+ */
+export declare class BundleQuery {
+    private readonly bundle;
+    constructor(bundle: BundleJsonApi<BundleEntry>);
+    /**
+     * Returns stable resource IDs from bundle entries with optional filters.
+     */
+    getResourceIds(filters?: BundleResourceIdFilters): string[];
+    /**
+     * Returns bundle entries matching resource IDs produced by `getResourceIds`.
+     */
+    getResourceEntriesByIds(resourceIds: readonly string[]): BundleEntry[];
+    /**
+     * Resolves the entry URL (`fullUrl`) for a given entry/resource identifier.
+     */
+    getEntryUrl(entryId: string): string | undefined;
+    private resolveBundleEntryId;
+    private resolveIdentifierFromClaims;
+    private matchesResourceFilters;
+    private matchesSections;
+    private resolveEntryDate;
+    private matchesDateRange;
+}