dop-wallet-v6 1.2.2 → 1.2.4

package/dist/services/dop/profile/storage.js

@@ -0,0 +1,648 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setProfileStorage = exports.getProfileStorage = exports.ProfileStorage = void 0;
+const engine_1 = require("../core/engine");
+const error_1 = require("../../../utils/error");
+// Database key prefixes for different data types
+const PROFILE_PREFIX = 'profile:';
+const SETTINGS_PREFIX = 'settings:';
+const PROOF_PREFIX = 'proof:';
+const VIEWING_REQUEST_PREFIX = 'viewing:';
+/**
+ * Storage utility for profile and selective transparency data using LevelDown
+ */
+class ProfileStorage {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    // Profile operations
+    async getProfile(walletId) {
+        try {
+            const key = `${PROFILE_PREFIX}${walletId}`;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const data = await new Promise((resolve, reject) => {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                this.db.get(key, // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                (err, value) => {
+                    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve(value);
+                    }
+                });
+            });
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            return JSON.parse(data.toString());
+        }
+        catch (err) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const error = err;
+            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+            if ( // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            error.notFound || error.type === 'NotFoundError' || error.message?.includes('NotFound')) {
+                return undefined;
+            }
+            throw (0, error_1.reportAndSanitizeError)('getProfile', err);
+        }
+    }
+    async setProfile(walletId, profile) {
+        try {
+            const key = `${PROFILE_PREFIX}${walletId}`;
+            // eslint-disable-next-line no-await-in-loop
+            await new Promise((resolve, reject) => {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                this.db.put(key, JSON.stringify(profile), // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                (err) => {
+                    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            });
+        }
+        catch (err) {
+            throw (0, error_1.reportAndSanitizeError)('setProfile', err);
+        }
+    }
+    async deleteProfile(walletId) {
+        try {
+            const key = `${PROFILE_PREFIX}${walletId}`;
+            // eslint-disable-next-line no-await-in-loop
+            await new Promise((resolve, reject) => {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                this.db.del(key, // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                (err) => {
+                    if (err && !err.notFound && err.type !== 'NotFoundError' && !err.message?.includes('NotFound')) {
+                        reject(err);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            });
+        }
+        catch (err) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const error = err;
+            if (!error.notFound && error.type !== 'NotFoundError' && !error.message?.includes('NotFound')) {
+                throw (0, error_1.reportAndSanitizeError)('deleteProfile', err);
+            }
+        }
+    }
+    // Selective transparency settings operations
+    async getSettings(walletId) {
+        try {
+            const key = `${SETTINGS_PREFIX}${walletId}`;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const data = await new Promise((resolve, reject) => {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                this.db.get(key, // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                (err, value) => {
+                    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve(value);
+                    }
+                });
+            });
+            const settings = JSON.parse(data.toString());
+            // Convert date strings back to Date objects
+            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+            if (settings.createdAt) // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                settings.createdAt = new Date(settings.createdAt);
+            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+            if (settings.updatedAt) // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                settings.updatedAt = new Date(settings.updatedAt);
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            return settings;
+        }
+        catch (err) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const error = err;
+            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+            if ( // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            error.notFound || error.type === 'NotFoundError' || error.message?.includes('NotFound')) {
+                return undefined;
+            }
+            throw (0, error_1.reportAndSanitizeError)('getSettings', err);
+        }
+    }
+    async setSettings(walletId, settings) {
+        try {
+            const key = `${SETTINGS_PREFIX}${walletId}`;
+            // eslint-disable-next-line no-await-in-loop
+            await new Promise((resolve, reject) => {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                this.db.put(key, JSON.stringify(settings), // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                (err) => {
+                    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            });
+        }
+        catch (err) {
+            throw (0, error_1.reportAndSanitizeError)('setSettings', err);
+        }
+    }
+    async deleteSettings(walletId) {
+        try {
+            const key = `${SETTINGS_PREFIX}${walletId}`;
+            // eslint-disable-next-line no-await-in-loop
+            await new Promise((resolve, reject) => {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                this.db.del(key, // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                (err) => {
+                    if (err && !err.notFound) {
+                        reject(err);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            });
+        }
+        catch (err) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const error = err;
+            if (!error.notFound) {
+                throw (0, error_1.reportAndSanitizeError)('deleteSettings', err);
+            }
+        }
+    }
+    // Visibility proof operations
+    async getProof(proofId) {
+        try {
+            const key = `${PROOF_PREFIX}${proofId}`;
+            const data = await new Promise((resolve, reject) => {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                this.db.get(key, // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                (err, value) => {
+                    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve(value);
+                    }
+                });
+            });
+            const proof = JSON.parse(data.toString());
+            // Convert date strings back to Date objects
+            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+            if (proof.createdAt) // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                proof.createdAt = new Date(proof.createdAt);
+            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+            if (proof.expiresAt) // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                proof.expiresAt = new Date(proof.expiresAt);
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            return proof;
+        }
+        catch // eslint-disable-next-line @typescript-eslint/no-explicit-any
+         (err) {
+            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+            if ( // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            err.notFound || err.type === 'NotFoundError' || err.message?.includes('NotFound')) {
+                return undefined;
+            }
+            throw (0, error_1.reportAndSanitizeError)('getProof', err);
+        }
+    }
+    async setProof(proofId, proof) {
+        try {
+            const key = `${PROOF_PREFIX}${proofId}`;
+            // eslint-disable-next-line no-await-in-loop
+            await new Promise((resolve, reject) => {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                this.db.put(key, JSON.stringify(proof), // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                (err) => {
+                    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            });
+        }
+        catch (err) {
+            throw (0, error_1.reportAndSanitizeError)('setProof', err);
+        }
+    }
+    async deleteProof(proofId) {
+        try {
+            const key = `${PROOF_PREFIX}${proofId}`;
+            // eslint-disable-next-line no-await-in-loop
+            await new Promise((resolve, reject) => {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                this.db.del(key, // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                (err) => {
+                    if (err && !err.notFound) {
+                        reject(err);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            });
+        }
+        catch // eslint-disable-next-line @typescript-eslint/no-explicit-any
+         (err) {
+            if (!err.notFound) {
+                throw (0, error_1.reportAndSanitizeError)('deleteProof', err);
+            }
+        }
+    }
+    // Viewing request operations
+    async getViewingRequest(requestId) {
+        try {
+            // Since the key now includes wallet ID, we need to scan to find the request
+            const iterator = // eslint-disable-next-line @typescript-eslint/no-explicit-any
+             this.db.iterator({
+                gte: `${VIEWING_REQUEST_PREFIX}`,
+                lt: `${VIEWING_REQUEST_PREFIX}~`,
+            });
+            return new Promise((resolve, reject) => {
+                const processNext = () => {
+                    iterator.next(// eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    (err, key, value) => {
+                        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                        if (err) {
+                            iterator.end(() => reject((0, error_1.reportAndSanitizeError)('getViewingRequest', err)));
+                            return;
+                        }
+                        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                        if (key === undefined) {
+                            iterator.end(() => resolve(undefined));
+                            return;
+                        }
+                        try {
+                            const request = JSON.parse(value.toString());
+                            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                            if (request.id === requestId) {
+                                // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                                // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                                if (request.createdAt) // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                                    request.createdAt = new Date(request.createdAt);
+                                // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                                // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                                if (request.expiresAt) // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                                    request.expiresAt = new Date(request.expiresAt);
+                                iterator.end(() => resolve(request));
+                                return;
+                            }
+                        }
+                        catch (parseErr) {
+                            iterator.end(() => reject((0, error_1.reportAndSanitizeError)('getViewingRequest', parseErr)));
+                            return;
+                        }
+                        processNext();
+                    });
+                };
+                processNext();
+            });
+        }
+        catch (err) {
+            throw (0, error_1.reportAndSanitizeError)('getViewingRequest', err);
+        }
+    }
+    async setViewingRequest(requestId, request) {
+        try {
+            // Store with wallet ID included in the key for efficient querying
+            const key = `${VIEWING_REQUEST_PREFIX}${request.walletId}:${requestId}`;
+            // eslint-disable-next-line no-await-in-loop
+            await new Promise((resolve, reject) => {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                this.db.put(key, JSON.stringify(request), // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                (err) => {
+                    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            });
+        }
+        catch (err) {
+            throw (0, error_1.reportAndSanitizeError)('setViewingRequest', err);
+        }
+    }
+    async deleteViewingRequest(requestId) {
+        try {
+            const key = `${VIEWING_REQUEST_PREFIX}${requestId}`;
+            // eslint-disable-next-line no-await-in-loop
+            await new Promise((resolve, reject) => {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                this.db.del(key, // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                (err) => {
+                    if (err && !err.notFound) {
+                        reject(err);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            });
+        }
+        catch // eslint-disable-next-line @typescript-eslint/no-explicit-any
+         (err) {
+            if (!err.notFound) {
+                throw (0, error_1.reportAndSanitizeError)('deleteViewingRequest', err);
+            }
+        }
+    }
+    // Batch operations for better performance
+    async getAllProofsForWallet(walletId) {
+        try {
+            const proofs = [];
+            const iterator = // eslint-disable-next-line @typescript-eslint/no-explicit-any
+             this.db.iterator({
+                gte: `${PROOF_PREFIX}${walletId}:`,
+                lt: `${PROOF_PREFIX}${walletId}:~`,
+            });
+            return new Promise((resolve, reject) => {
+                const processNext = () => {
+                    iterator.next(// eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    (err, key, value) => {
+                        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                        if (err) {
+                            iterator.end(() => reject((0, error_1.reportAndSanitizeError)('getAllProofsForWallet', err)));
+                            return;
+                        }
+                        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                        if (key === undefined) {
+                            iterator.end(() => resolve(proofs));
+                            return;
+                        }
+                        try {
+                            const proof = JSON.parse(value.toString());
+                            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                            if (proof.createdAt) // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                                proof.createdAt = new Date(proof.createdAt);
+                            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                            if (proof.expiresAt) // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                                proof.expiresAt = new Date(proof.expiresAt);
+                            proofs.push(proof);
+                        }
+                        catch (parseErr) {
+                            iterator.end(() => reject((0, error_1.reportAndSanitizeError)('getAllProofsForWallet', parseErr)));
+                            return;
+                        }
+                        processNext();
+                    });
+                };
+                processNext();
+            });
+        }
+        catch (err) {
+            throw (0, error_1.reportAndSanitizeError)('getAllProofsForWallet', err);
+        }
+    }
+    async getAllViewingRequestsForWallet(walletId) {
+        try {
+            const requests = [];
+            const iterator = // eslint-disable-next-line @typescript-eslint/no-explicit-any
+             this.db.iterator({
+                gte: `${VIEWING_REQUEST_PREFIX}${walletId}:`,
+                lt: `${VIEWING_REQUEST_PREFIX}${walletId}:~`,
+            });
+            return new Promise((resolve, reject) => {
+                const processNext = () => {
+                    iterator.next(// eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    (err, key, value) => {
+                        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                        if (err) {
+                            iterator.end(() => reject((0, error_1.reportAndSanitizeError)('getAllViewingRequestsForWallet', err)));
+                            return;
+                        }
+                        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                        if (key === undefined) {
+                            iterator.end(() => resolve(requests));
+                            return;
+                        }
+                        try {
+                            const request = JSON.parse(value.toString());
+                            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                            if (request.createdAt) // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                                request.createdAt = new Date(request.createdAt);
+                            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                            if (request.expiresAt) // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                                request.expiresAt = new Date(request.expiresAt);
+                            requests.push(request);
+                        }
+                        catch (parseErr) {
+                            iterator.end(() => reject((0, error_1.reportAndSanitizeError)('getAllViewingRequestsForWallet', parseErr)));
+                            return;
+                        }
+                        processNext();
+                    });
+                };
+                processNext();
+            });
+        }
+        catch (err) {
+            throw (0, error_1.reportAndSanitizeError)('getAllViewingRequestsForWallet', err);
+        }
+    }
+    // Cleanup expired data
+    async cleanupExpiredProofs() {
+        try {
+            const now = new Date();
+            const iterator = // eslint-disable-next-line @typescript-eslint/no-explicit-any
+             this.db.iterator({
+                gte: PROOF_PREFIX,
+                lt: `${PROOF_PREFIX}~`,
+            });
+            const expiredKeys = [];
+            return new Promise((resolve, reject) => {
+                const processNext = () => {
+                    iterator.next(// eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    (err, key, value) => {
+                        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                        if (err) {
+                            iterator.end(() => reject((0, error_1.reportAndSanitizeError)('cleanupExpiredProofs', err)));
+                            return;
+                        }
+                        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                        if (key === undefined) {
+                            // eslint-disable-next-line @typescript-eslint/no-misused-promises
+                            iterator.end(async () => {
+                                // Delete expired keys
+                                // eslint-disable-next-line no-await-in-loop
+                                for (const expiredKey of expiredKeys) {
+                                    try {
+                                        // eslint-disable-next-line no-await-in-loop
+                                        await new Promise((resolve, reject) => {
+                                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                                            this.db.del(expiredKey, // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                                            (err) => {
+                                                if (err && !err.notFound) {
+                                                    reject(err);
+                                                }
+                                                else {
+                                                    resolve();
+                                                }
+                                            });
+                                        });
+                                    }
+                                    catch (delErr) {
+                                        // Ignore if key doesn't exist
+                                    }
+                                }
+                                resolve();
+                            });
+                            return;
+                        }
+                        try {
+                            const proof = JSON.parse(value.toString());
+                            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                            if (proof.expiresAt && new Date(proof.expiresAt) < now) {
+                                expiredKeys.push(key.toString());
+                            }
+                        }
+                        catch (parseErr) {
+                            // Skip malformed entries
+                        }
+                        processNext();
+                    });
+                };
+                processNext();
+            });
+        }
+        catch (err) {
+            throw (0, error_1.reportAndSanitizeError)('cleanupExpiredProofs', err);
+        }
+    }
+    async cleanupExpiredViewingRequests() {
+        try {
+            const now = new Date();
+            const iterator = // eslint-disable-next-line @typescript-eslint/no-explicit-any
+             this.db.iterator({
+                gte: VIEWING_REQUEST_PREFIX,
+                lt: `${VIEWING_REQUEST_PREFIX}~`,
+            });
+            const expiredKeys = [];
+            return new Promise((resolve, reject) => {
+                const processNext = () => {
+                    iterator.next(// eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    (err, key, value) => {
+                        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                        if (err) {
+                            iterator.end(() => reject((0, error_1.reportAndSanitizeError)('cleanupExpiredViewingRequests', err)));
+                            return;
+                        }
+                        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                        if (key === undefined) {
+                            // eslint-disable-next-line @typescript-eslint/no-misused-promises
+                            iterator.end(async () => {
+                                // Delete expired keys
+                                // eslint-disable-next-line no-await-in-loop
+                                for (const expiredKey of expiredKeys) {
+                                    try {
+                                        // eslint-disable-next-line no-await-in-loop
+                                        await new Promise((resolve, reject) => {
+                                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                                            this.db.del(expiredKey, // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                                            (err) => {
+                                                if (err && !err.notFound) {
+                                                    reject(err);
+                                                }
+                                                else {
+                                                    resolve();
+                                                }
+                                            });
+                                        });
+                                    }
+                                    catch (delErr) {
+                                        // Ignore if key doesn't exist
+                                    }
+                                }
+                                resolve();
+                            });
+                            return;
+                        }
+                        try {
+                            const request = JSON.parse(value.toString());
+                            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+                            if (request.expiresAt && new Date(request.expiresAt) < now) {
+                                expiredKeys.push(key.toString());
+                            }
+                        }
+                        catch (parseErr) {
+                            // Skip malformed entries
+                        }
+                        processNext();
+                    });
+                };
+                processNext();
+            });
+        }
+        catch (err) {
+            throw (0, error_1.reportAndSanitizeError)('cleanupExpiredViewingRequests', err);
+        }
+    }
+}
+exports.ProfileStorage = ProfileStorage;
+// Singleton instance that uses the same database as the DOP engine
+let storageInstance;
+const getProfileStorage = () => {
+    if (!storageInstance) {
+        const engine = (0, engine_1.getEngine)();
+        // Access the database from the engine's internals
+        // Note: This assumes the DOP engine exposes its database instance
+        // If not available, you might need to store the db instance separately
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const db = engine.db || engine.database || engine.leveldb;
+        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+        if (!db) {
+            throw new Error('Cannot access database instance from DOP engine');
+        }
+        storageInstance = new ProfileStorage(db);
+    }
+    return storageInstance;
+};
+exports.getProfileStorage = getProfileStorage;
+const setProfileStorage = (storage) => {
+    storageInstance = storage;
+};
+exports.setProfileStorage = setProfileStorage;
+//# sourceMappingURL=storage.js.map