export async function getDocumentLedgerMetadata()

in src/GetMetadata.ts [87:179]
72 lines of code
8 McCabe index (conditional complexity)

export async function getDocumentLedgerMetadata(
    txn: TransactionExecutor,
    ledgerName: string,
    tableName: string,
    keyAttributeName: string,
    keyAttributeValue: string,
    qldbClient: QLDB,
    ledgerDigest?: LedgerDigest
): Promise<LedgerMetadata> {
    const fcnName = "[GetMetadata getDocumentLedgerMetadata]";

    try {
        logger.debug(`${fcnName} Getting metadata for document with "${keyAttributeName}" = ${keyAttributeValue}, in ledger = ${ledgerName}.`);

        // Getting Block Address and Document Id for the document
        logger.debug(`${fcnName} Getting Block Address and Document Id for the document`);
        const blockAddressAndIdList: dom.Value[] = await lookupBlockAddressAndDocIdForKey(txn, tableName, keyAttributeName, keyAttributeValue);

        logger.debug(`${fcnName} Received ${blockAddressAndIdList.length} Block Address and Document Id combination.`);
        if (!blockAddressAndIdList.length) {
            throw `Unable to find block address and document id associated with "${keyAttributeName}" = ${keyAttributeValue}`
        }
        const blockAddressAndId = blockAddressAndIdList[blockAddressAndIdList.length - 1]
        const blockAddress: ValueHolder = blockAddressToValueHolder(blockAddressAndId);

        logger.debug(`${fcnName} Getting a proof for the document.`);

        let digest: LedgerDigest = ledgerDigest;

        if (!ledgerDigest) {
            // Requesting ledger digest
            logger.debug(`${fcnName} Requesting ledger digest`);
            let ledgerDigest = await getLedgerDigest(ledgerName, qldbClient);

            // Checking if digest sequenceNo has caught up with block sequenceNo
            const digestTipAddressSeqNo = dom.load(ledgerDigest.DigestTipAddress.IonText).get("sequenceNo");
            const blockAddressSeqNo = dom.load(blockAddress.IonText).get("sequenceNo");
            if (digestTipAddressSeqNo < blockAddressSeqNo) {
                logger.debug(`${fcnName} The ledger digest sequenceNo is behind the block sequenceNo, so retrying after 100 ms`);
                await sleep(100);
                ledgerDigest = await getLedgerDigest(ledgerName, qldbClient);
            }

            const digestBase64: Base64EncodedString = toBase64(<Uint8Array>ledgerDigest.Digest);
            digest = {
                Digest: digestBase64,
                DigestTipAddress: ledgerDigest.DigestTipAddress
            }

            logger.debug(`${fcnName} Got Ledger Digest: ${JSON.stringify(digest)} `)
        }

        // Converting digest from default buffer array to base64 format
        const digestTipAddress: ValueHolder = digest.DigestTipAddress;

        logger.debug(`${fcnName} Got a ledger digest: digest tip address = ${valueHolderToString(digestTipAddress)}, \n digest = ${digest.Digest}.`);

        // Getting revision
        const documentId: string = getMetadataId(blockAddressAndId);

        logger.debug(`${fcnName} Getting document revision with the following parameters: ${JSON.stringify({
            ledgerName: ledgerName,
            documentId: documentId,
            blockAddress: blockAddress,
            digestTipAddress: digestTipAddress
        })}`);

        const revisionResponse: GetRevisionResponse = await getRevision(
            ledgerName,
            documentId,
            blockAddress,
            digestTipAddress,
            qldbClient
        );

        const revision: dom.Value = dom.load(revisionResponse.Revision.IonText);
        const revisionHash: Base64EncodedString = toBase64(<Uint8Array>getBlobValue(revision, "hash"));
        const proof: ValueHolder = revisionResponse.Proof;
        logger.debug(`${fcnName} Got back a proof: ${valueHolderToString(proof)}.`);

        return {
            LedgerName: ledgerName,
            TableName: tableName,
            BlockAddress: blockAddress,
            DocumentId: documentId,
            RevisionHash: revisionHash,
            Proof: proof,
            LedgerDigest: digest
        };
    } catch (err) {
        throw `${fcnName} ${err} `
    }
}