@brightchain/brightchain-api-lib 0.18.2 → 0.21.0

package/src/lib/services/quorumDatabaseAdapter.js

@@ -0,0 +1,652 @@
+"use strict";
+/**
+ * QuorumDatabaseAdapter — BrightChainDb-backed implementation of IQuorumDatabase.
+ *
+ * Uses a dedicated BrightChainDb instance with pool ID "quorum-system" for
+ * isolated storage of all quorum-related data. Each data type is stored in
+ * a separate collection.
+ *
+ * This is a Node.js-specific service that lives in brightchain-api-lib.
+ *
+ * @see Requirements 9, 10
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuorumDatabaseAdapter = exports.QUORUM_SYSTEM_POOL_ID = void 0;
+// ─── Collection Names ───────────────────────────────────────────────────────
+const COLLECTION_EPOCHS = 'epochs';
+const COLLECTION_MEMBERS = 'members';
+const COLLECTION_DOCUMENTS = 'documents';
+const COLLECTION_PROPOSALS = 'proposals';
+const COLLECTION_VOTES = 'votes';
+const COLLECTION_IDENTITY_RECORDS = 'identity_records';
+const COLLECTION_ALIASES = 'aliases';
+const COLLECTION_AUDIT_LOG = 'audit_log';
+const COLLECTION_REDISTRIBUTION_JOURNAL = 'redistribution_journal';
+const COLLECTION_STATUTE_CONFIG = 'statute_config';
+const COLLECTION_OPERATIONAL_STATE = 'operational_state';
+/** Dedicated pool ID for quorum data isolation */
+exports.QUORUM_SYSTEM_POOL_ID = 'quorum-system';
+// ─── Serialization Helpers ──────────────────────────────────────────────────
+function serializeMap(map) {
+    const result = {};
+    for (const [key, value] of map.entries()) {
+        result[key] = Buffer.from(value).toString('base64');
+    }
+    return result;
+}
+function deserializeMap(obj) {
+    const map = new Map();
+    for (const [key, value] of Object.entries(obj)) {
+        map.set(key, Buffer.from(value, 'base64'));
+    }
+    return map;
+}
+function serializeDurationsMap(map) {
+    const result = {};
+    for (const [key, value] of map.entries()) {
+        result[key] = value;
+    }
+    return result;
+}
+function deserializeDurationsMap(obj) {
+    const map = new Map();
+    for (const [key, value] of Object.entries(obj)) {
+        map.set(key, value);
+    }
+    return map;
+}
+function serializeUint8Array(arr) {
+    return Buffer.from(arr).toString('base64');
+}
+function deserializeUint8Array(str) {
+    return new Uint8Array(Buffer.from(str, 'base64'));
+}
+// ─── Epoch Serialization ────────────────────────────────────────────────────
+function serializeEpoch(epoch) {
+    return {
+        epochNumber: epoch.epochNumber,
+        memberIds: epoch.memberIds,
+        threshold: epoch.threshold,
+        mode: epoch.mode,
+        createdAt: epoch.createdAt.toISOString(),
+        previousEpochNumber: epoch.previousEpochNumber,
+        innerQuorumMemberIds: epoch.innerQuorumMemberIds,
+    };
+}
+function deserializeEpoch(data) {
+    return {
+        epochNumber: data['epochNumber'],
+        memberIds: data['memberIds'],
+        threshold: data['threshold'],
+        mode: data['mode'],
+        createdAt: new Date(data['createdAt']),
+        previousEpochNumber: data['previousEpochNumber'],
+        innerQuorumMemberIds: data['innerQuorumMemberIds'],
+    };
+}
+// ─── Member Serialization ───────────────────────────────────────────────────
+function serializeMember(member) {
+    return {
+        id: member.id,
+        publicKey: serializeUint8Array(member.publicKey),
+        metadata: member.metadata,
+        isActive: member.isActive,
+        createdAt: member.createdAt.toISOString(),
+        updatedAt: member.updatedAt.toISOString(),
+    };
+}
+function deserializeMember(data) {
+    return {
+        id: data['id'],
+        publicKey: deserializeUint8Array(data['publicKey']),
+        metadata: data['metadata'],
+        isActive: data['isActive'],
+        createdAt: new Date(data['createdAt']),
+        updatedAt: new Date(data['updatedAt']),
+    };
+}
+// ─── Proposal Serialization ─────────────────────────────────────────────────
+function serializeProposal(proposal) {
+    return {
+        id: proposal.id,
+        description: proposal.description,
+        actionType: proposal.actionType,
+        actionPayload: proposal.actionPayload,
+        proposerMemberId: proposal.proposerMemberId,
+        status: proposal.status,
+        requiredThreshold: proposal.requiredThreshold,
+        expiresAt: proposal.expiresAt.toISOString(),
+        createdAt: proposal.createdAt.toISOString(),
+        attachmentCblId: proposal.attachmentCblId,
+        epochNumber: proposal.epochNumber,
+    };
+}
+function deserializeProposal(data) {
+    return {
+        id: data['id'],
+        description: data['description'],
+        actionType: data['actionType'],
+        actionPayload: data['actionPayload'],
+        proposerMemberId: data['proposerMemberId'],
+        status: data['status'],
+        requiredThreshold: data['requiredThreshold'],
+        expiresAt: new Date(data['expiresAt']),
+        createdAt: new Date(data['createdAt']),
+        attachmentCblId: data['attachmentCblId'],
+        epochNumber: data['epochNumber'],
+    };
+}
+// ─── Vote Serialization ─────────────────────────────────────────────────────
+function serializeVote(vote) {
+    return {
+        proposalId: vote.proposalId,
+        voterMemberId: vote.voterMemberId,
+        decision: vote.decision,
+        comment: vote.comment,
+        encryptedShare: vote.encryptedShare
+            ? serializeUint8Array(vote.encryptedShare)
+            : undefined,
+        createdAt: vote.createdAt.toISOString(),
+    };
+}
+function deserializeVote(data) {
+    return {
+        proposalId: data['proposalId'],
+        voterMemberId: data['voterMemberId'],
+        decision: data['decision'],
+        comment: data['comment'],
+        encryptedShare: data['encryptedShare']
+            ? deserializeUint8Array(data['encryptedShare'])
+            : undefined,
+        createdAt: new Date(data['createdAt']),
+    };
+}
+// ─── IdentityRecoveryRecord Serialization ───────────────────────────────────
+function serializeIdentityRecord(record) {
+    return {
+        id: record.id,
+        contentId: record.contentId,
+        contentType: record.contentType,
+        encryptedShardsByMemberId: serializeMap(record.encryptedShardsByMemberId),
+        memberIds: record.memberIds,
+        threshold: record.threshold,
+        epochNumber: record.epochNumber,
+        expiresAt: record.expiresAt.toISOString(),
+        createdAt: record.createdAt.toISOString(),
+        identityMode: record.identityMode,
+        aliasName: record.aliasName,
+    };
+}
+function deserializeIdentityRecord(data) {
+    return {
+        id: data['id'],
+        contentId: data['contentId'],
+        contentType: data['contentType'],
+        encryptedShardsByMemberId: deserializeMap(data['encryptedShardsByMemberId']),
+        memberIds: data['memberIds'],
+        threshold: data['threshold'],
+        epochNumber: data['epochNumber'],
+        expiresAt: new Date(data['expiresAt']),
+        createdAt: new Date(data['createdAt']),
+        identityMode: data['identityMode'],
+        aliasName: data['aliasName'],
+    };
+}
+// ─── AliasRecord Serialization ──────────────────────────────────────────────
+function serializeAlias(alias) {
+    return {
+        aliasName: alias.aliasName,
+        ownerMemberId: alias.ownerMemberId,
+        aliasPublicKey: serializeUint8Array(alias.aliasPublicKey),
+        identityRecoveryRecordId: alias.identityRecoveryRecordId,
+        isActive: alias.isActive,
+        registeredAt: alias.registeredAt.toISOString(),
+        deactivatedAt: alias.deactivatedAt?.toISOString(),
+        epochNumber: alias.epochNumber,
+    };
+}
+function deserializeAlias(data) {
+    return {
+        aliasName: data['aliasName'],
+        ownerMemberId: data['ownerMemberId'],
+        aliasPublicKey: deserializeUint8Array(data['aliasPublicKey']),
+        identityRecoveryRecordId: data['identityRecoveryRecordId'],
+        isActive: data['isActive'],
+        registeredAt: new Date(data['registeredAt']),
+        deactivatedAt: data['deactivatedAt']
+            ? new Date(data['deactivatedAt'])
+            : undefined,
+        epochNumber: data['epochNumber'],
+    };
+}
+// ─── AuditLogEntry Serialization ────────────────────────────────────────────
+function serializeAuditEntry(entry) {
+    const base = {
+        id: entry.id,
+        eventType: entry.eventType,
+        proposalId: entry.proposalId,
+        targetMemberId: entry.targetMemberId,
+        proposerMemberId: entry.proposerMemberId,
+        attachmentCblId: entry.attachmentCblId,
+        details: entry.details,
+        timestamp: entry.timestamp.toISOString(),
+    };
+    // If this is a ChainedAuditLogEntry, also serialize chain fields
+    const chained = entry;
+    if (chained.contentHash !== undefined) {
+        base['previousEntryHash'] = chained.previousEntryHash;
+        base['contentHash'] = chained.contentHash;
+        base['signature'] = chained.signature
+            ? serializeUint8Array(chained.signature)
+            : undefined;
+        base['blockId1'] = chained.blockId1;
+        base['blockId2'] = chained.blockId2;
+    }
+    return base;
+}
+function deserializeChainedAuditEntry(data) {
+    return {
+        id: data['id'],
+        eventType: data['eventType'],
+        proposalId: data['proposalId'],
+        targetMemberId: data['targetMemberId'],
+        proposerMemberId: data['proposerMemberId'],
+        attachmentCblId: data['attachmentCblId'],
+        details: data['details'],
+        timestamp: new Date(data['timestamp']),
+        previousEntryHash: data['previousEntryHash'] ?? null,
+        contentHash: data['contentHash'] ?? '',
+        signature: (data['signature']
+            ? deserializeUint8Array(data['signature'])
+            : new Uint8Array(0)),
+        blockId1: data['blockId1'] ?? '',
+        blockId2: data['blockId2'] ?? '',
+    };
+}
+// ─── RedistributionJournalEntry Serialization ───────────────────────────────
+function serializeJournalEntry(entry) {
+    return {
+        documentId: entry.documentId,
+        oldShares: serializeMap(entry.oldShares),
+        oldMemberIds: entry.oldMemberIds,
+        oldThreshold: entry.oldThreshold,
+        oldEpoch: entry.oldEpoch,
+    };
+}
+function deserializeJournalEntry(data) {
+    return {
+        documentId: data['documentId'],
+        oldShares: deserializeMap(data['oldShares']),
+        oldMemberIds: data['oldMemberIds'],
+        oldThreshold: data['oldThreshold'],
+        oldEpoch: data['oldEpoch'],
+    };
+}
+// ─── StatuteOfLimitationsConfig Serialization ───────────────────────────────
+function serializeStatuteConfig(config) {
+    return {
+        defaultDurations: serializeDurationsMap(config.defaultDurations),
+        fallbackDurationMs: config.fallbackDurationMs,
+    };
+}
+function deserializeStatuteConfig(data) {
+    return {
+        defaultDurations: deserializeDurationsMap(data['defaultDurations']),
+        fallbackDurationMs: data['fallbackDurationMs'],
+    };
+}
+// ─── OperationalState Serialization ─────────────────────────────────────────
+function serializeOperationalState(state) {
+    return {
+        mode: state.mode,
+        currentEpochNumber: state.currentEpochNumber,
+        lastUpdated: state.lastUpdated.toISOString(),
+    };
+}
+function deserializeOperationalState(data) {
+    return {
+        mode: data['mode'],
+        currentEpochNumber: data['currentEpochNumber'],
+        lastUpdated: new Date(data['lastUpdated']),
+    };
+}
+// ─── QuorumDatabaseAdapter ──────────────────────────────────────────────────
+/**
+ * BrightChainDb-backed implementation of IQuorumDatabase.
+ *
+ * Uses a dedicated pool ID ("quorum-system") for isolated storage.
+ * Each data type is stored in a separate collection.
+ *
+ * @template TID - Platform ID type for frontend/backend DTO compatibility
+ */
+class QuorumDatabaseAdapter {
+    constructor(db) {
+        this.db = db;
+    }
+    // === Epoch Management ===
+    async saveEpoch(epoch) {
+        const col = this.db.collection(COLLECTION_EPOCHS);
+        const existing = await col.findOne({
+            epochNumber: epoch.epochNumber,
+        });
+        if (existing) {
+            await col.updateOne({ epochNumber: epoch.epochNumber }, { $set: { data: serializeEpoch(epoch) } });
+        }
+        else {
+            await col.insertOne({
+                epochNumber: epoch.epochNumber,
+                data: serializeEpoch(epoch),
+            });
+        }
+    }
+    async getEpoch(epochNumber) {
+        const col = this.db.collection(COLLECTION_EPOCHS);
+        const doc = await col.findOne({ epochNumber });
+        if (!doc)
+            return null;
+        return deserializeEpoch(doc.data);
+    }
+    async getCurrentEpoch() {
+        const col = this.db.collection(COLLECTION_EPOCHS);
+        const docs = await col
+            .find({})
+            .sort({ epochNumber: -1 })
+            .limit(1)
+            .toArray();
+        if (docs.length === 0) {
+            throw new Error('No epochs found in quorum database');
+        }
+        return deserializeEpoch(docs[0].data);
+    }
+    // === Member Management ===
+    async saveMember(member) {
+        const col = this.db.collection(COLLECTION_MEMBERS);
+        const existing = await col.findOne({ memberId: member.id });
+        if (existing) {
+            await col.updateOne({ memberId: member.id }, {
+                $set: {
+                    isActive: member.isActive,
+                    data: serializeMember(member),
+                },
+            });
+        }
+        else {
+            await col.insertOne({
+                memberId: member.id,
+                isActive: member.isActive,
+                data: serializeMember(member),
+            });
+        }
+    }
+    async getMember(memberId) {
+        const col = this.db.collection(COLLECTION_MEMBERS);
+        const doc = await col.findOne({ memberId });
+        if (!doc)
+            return null;
+        return deserializeMember(doc.data);
+    }
+    async listActiveMembers() {
+        const col = this.db.collection(COLLECTION_MEMBERS);
+        const docs = await col.find({ isActive: true }).toArray();
+        return docs.map((doc) => deserializeMember(doc.data));
+    }
+    // === Sealed Documents ===
+    async saveDocument(doc) {
+        const col = this.db.collection(COLLECTION_DOCUMENTS);
+        const dto = doc.toDto();
+        const docId = dto.id;
+        const existing = await col.findOne({ docId });
+        if (existing) {
+            await col.updateOne({ docId }, {
+                $set: {
+                    epochNumber: dto.epochNumber,
+                    data: dto,
+                },
+            });
+        }
+        else {
+            await col.insertOne({
+                docId,
+                epochNumber: dto.epochNumber,
+                data: dto,
+            });
+        }
+    }
+    async getDocument(docId) {
+        const col = this.db.collection(COLLECTION_DOCUMENTS);
+        const doc = await col.findOne({ docId });
+        if (!doc)
+            return null;
+        // Return the stored DTO data — callers use QuorumDataRecord.fromDto
+        // to reconstruct the full object with crypto services.
+        return doc.data;
+    }
+    async listDocumentsByEpoch(epochNumber, page, pageSize) {
+        const col = this.db.collection(COLLECTION_DOCUMENTS);
+        const docs = await col
+            .find({ epochNumber })
+            .skip(page * pageSize)
+            .limit(pageSize)
+            .toArray();
+        return docs.map((d) => d.data);
+    }
+    // === Proposals and Votes ===
+    async saveProposal(proposal) {
+        const col = this.db.collection(COLLECTION_PROPOSALS);
+        const existing = await col.findOne({ proposalId: proposal.id });
+        if (existing) {
+            await col.updateOne({ proposalId: proposal.id }, { $set: { data: serializeProposal(proposal) } });
+        }
+        else {
+            await col.insertOne({
+                proposalId: proposal.id,
+                data: serializeProposal(proposal),
+            });
+        }
+    }
+    async getProposal(proposalId) {
+        const col = this.db.collection(COLLECTION_PROPOSALS);
+        const doc = await col.findOne({ proposalId });
+        if (!doc)
+            return null;
+        return deserializeProposal(doc.data);
+    }
+    async saveVote(vote) {
+        const col = this.db.collection(COLLECTION_VOTES);
+        const existing = await col.findOne({
+            proposalId: vote.proposalId,
+            voterMemberId: vote.voterMemberId,
+        });
+        if (existing) {
+            await col.updateOne({
+                proposalId: vote.proposalId,
+                voterMemberId: vote.voterMemberId,
+            }, { $set: { data: serializeVote(vote) } });
+        }
+        else {
+            await col.insertOne({
+                proposalId: vote.proposalId,
+                voterMemberId: vote.voterMemberId,
+                data: serializeVote(vote),
+            });
+        }
+    }
+    async getVotesForProposal(proposalId) {
+        const col = this.db.collection(COLLECTION_VOTES);
+        const docs = await col.find({ proposalId }).toArray();
+        return docs.map((d) => deserializeVote(d.data));
+    }
+    // === Identity Recovery Records ===
+    async saveIdentityRecord(record) {
+        const col = this.db.collection(COLLECTION_IDENTITY_RECORDS);
+        const existing = await col.findOne({ recordId: record.id });
+        if (existing) {
+            await col.updateOne({ recordId: record.id }, {
+                $set: {
+                    expiresAt: record.expiresAt.toISOString(),
+                    data: serializeIdentityRecord(record),
+                },
+            });
+        }
+        else {
+            await col.insertOne({
+                recordId: record.id,
+                expiresAt: record.expiresAt.toISOString(),
+                data: serializeIdentityRecord(record),
+            });
+        }
+    }
+    async getIdentityRecord(recordId) {
+        const col = this.db.collection(COLLECTION_IDENTITY_RECORDS);
+        const doc = await col.findOne({ recordId });
+        if (!doc)
+            return null;
+        return deserializeIdentityRecord(doc.data);
+    }
+    async deleteIdentityRecord(recordId) {
+        const col = this.db.collection(COLLECTION_IDENTITY_RECORDS);
+        await col.deleteOne({ recordId });
+    }
+    async listExpiredIdentityRecords(before, page, pageSize) {
+        const col = this.db.collection(COLLECTION_IDENTITY_RECORDS);
+        // Fetch all records and filter in-memory since the collection
+        // doesn't support $lt on ISO string fields natively.
+        const allDocs = await col.find({}).toArray();
+        const beforeIso = before.toISOString();
+        const expired = allDocs
+            .filter((d) => d.expiresAt < beforeIso)
+            .sort((a, b) => a.expiresAt.localeCompare(b.expiresAt));
+        const start = page * pageSize;
+        const paged = expired.slice(start, start + pageSize);
+        return paged.map((d) => deserializeIdentityRecord(d.data));
+    }
+    // === Alias Registry ===
+    async saveAlias(alias) {
+        const col = this.db.collection(COLLECTION_ALIASES);
+        const existing = await col.findOne({ aliasName: alias.aliasName });
+        if (existing) {
+            await col.updateOne({ aliasName: alias.aliasName }, {
+                $set: {
+                    isActive: alias.isActive,
+                    data: serializeAlias(alias),
+                },
+            });
+        }
+        else {
+            await col.insertOne({
+                aliasName: alias.aliasName,
+                isActive: alias.isActive,
+                data: serializeAlias(alias),
+            });
+        }
+    }
+    async getAlias(aliasName) {
+        const col = this.db.collection(COLLECTION_ALIASES);
+        const doc = await col.findOne({ aliasName });
+        if (!doc)
+            return null;
+        return deserializeAlias(doc.data);
+    }
+    async isAliasAvailable(aliasName) {
+        const col = this.db.collection(COLLECTION_ALIASES);
+        const doc = await col.findOne({ aliasName });
+        // Available if no record exists or the existing record is inactive
+        return doc === null || !doc.isActive;
+    }
+    // === Audit Log ===
+    async appendAuditEntry(entry) {
+        const col = this.db.collection(COLLECTION_AUDIT_LOG);
+        await col.insertOne({
+            entryId: entry.id,
+            timestamp: entry.timestamp.toISOString(),
+            data: serializeAuditEntry(entry),
+        });
+    }
+    async getLatestAuditEntry() {
+        const col = this.db.collection(COLLECTION_AUDIT_LOG);
+        const docs = await col.find({}).sort({ timestamp: -1 }).limit(1).toArray();
+        if (docs.length === 0)
+            return null;
+        return deserializeChainedAuditEntry(docs[0].data);
+    }
+    // === Redistribution Journal ===
+    async saveJournalEntry(entry) {
+        const col = this.db.collection(COLLECTION_REDISTRIBUTION_JOURNAL);
+        await col.insertOne({
+            documentId: entry.documentId,
+            oldEpoch: entry.oldEpoch,
+            data: serializeJournalEntry(entry),
+        });
+    }
+    async getJournalEntries(epochNumber) {
+        const col = this.db.collection(COLLECTION_REDISTRIBUTION_JOURNAL);
+        const docs = await col.find({ oldEpoch: epochNumber }).toArray();
+        return docs.map((d) => deserializeJournalEntry(d.data));
+    }
+    async deleteJournalEntries(epochNumber) {
+        const col = this.db.collection(COLLECTION_REDISTRIBUTION_JOURNAL);
+        await col.deleteMany({ oldEpoch: epochNumber });
+    }
+    // === Statute of Limitations Configuration ===
+    async saveStatuteConfig(config) {
+        const col = this.db.collection(COLLECTION_STATUTE_CONFIG);
+        const existing = await col.findOne({ key: 'statute_config' });
+        if (existing) {
+            await col.updateOne({ key: 'statute_config' }, { $set: { data: serializeStatuteConfig(config) } });
+        }
+        else {
+            await col.insertOne({
+                key: 'statute_config',
+                data: serializeStatuteConfig(config),
+            });
+        }
+    }
+    async getStatuteConfig() {
+        const col = this.db.collection(COLLECTION_STATUTE_CONFIG);
+        const doc = await col.findOne({ key: 'statute_config' });
+        if (!doc)
+            return null;
+        return deserializeStatuteConfig(doc.data);
+    }
+    // === Operational State ===
+    async saveOperationalState(state) {
+        const col = this.db.collection(COLLECTION_OPERATIONAL_STATE);
+        const existing = await col.findOne({ key: 'operational_state' });
+        if (existing) {
+            await col.updateOne({ key: 'operational_state' }, { $set: { data: serializeOperationalState(state) } });
+        }
+        else {
+            await col.insertOne({
+                key: 'operational_state',
+                data: serializeOperationalState(state),
+            });
+        }
+    }
+    async getOperationalState() {
+        const col = this.db.collection(COLLECTION_OPERATIONAL_STATE);
+        const doc = await col.findOne({ key: 'operational_state' });
+        if (!doc)
+            return null;
+        return deserializeOperationalState(doc.data);
+    }
+    // === Transactions ===
+    async withTransaction(fn) {
+        return this.db.withTransaction(async () => {
+            return fn();
+        });
+    }
+    // === Health Check ===
+    async isAvailable() {
+        try {
+            // Try a simple operation to verify the database is accessible
+            const col = this.db.collection(COLLECTION_OPERATIONAL_STATE);
+            await col.estimatedDocumentCount();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+exports.QuorumDatabaseAdapter = QuorumDatabaseAdapter;
+//# sourceMappingURL=quorumDatabaseAdapter.js.map