@didcid/gatekeeper 0.1.3

package/dist/cjs/db/redis.cjs

@@ -0,0 +1,291 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var ioredis = require('ioredis');
+var errors = require('../errors-DQaog-FG.cjs');
+
+const REDIS_NOT_STARTED_ERROR = 'Redis not started. Call start() first.';
+class DbRedis {
+    dbName;
+    redis;
+    _lock = Promise.resolve();
+    runExclusive(fn) {
+        const run = async () => await fn();
+        const chained = this._lock.then(run, run);
+        this._lock = chained.then(() => undefined, () => undefined);
+        return chained;
+    }
+    constructor(dbName) {
+        this.dbName = dbName;
+        this.redis = null;
+    }
+    async start() {
+        const url = process.env.ARCHON_REDIS_URL || 'redis://localhost:6379';
+        this.redis = new ioredis.Redis(url);
+    }
+    async stop() {
+        if (this.redis) {
+            await this.redis.quit();
+            this.redis = null;
+        }
+    }
+    async resetDb() {
+        if (!this.redis) {
+            throw new Error(REDIS_NOT_STARTED_ERROR);
+        }
+        let cursor = '0';
+        let totalDeleted = 0;
+        do {
+            // Scan for keys that match the pattern
+            const [newCursor, keys] = await this.redis.scan(cursor, 'MATCH', `${this.dbName}/*`, 'COUNT', 1000);
+            cursor = newCursor;
+            if (keys.length > 0) {
+                // Delete the keys found
+                const deletedCount = await this.redis.del(...keys);
+                totalDeleted += deletedCount; // Increment the total count
+            }
+        } while (cursor !== '0'); // Continue scanning until cursor returns to 0
+        return totalDeleted;
+    }
+    async addEvent(did, event) {
+        if (!this.redis) {
+            throw new Error(REDIS_NOT_STARTED_ERROR);
+        }
+        // Store operation separately if present
+        if (event.opid && event.operation) {
+            await this.addOperation(event.opid, event.operation);
+        }
+        const key = this.didKey(did);
+        // Strip operation and store only opid reference
+        const { operation, ...strippedEvent } = event;
+        const val = JSON.stringify(strippedEvent);
+        return this.redis.rpush(key, val);
+    }
+    async setEvents(did, events) {
+        if (!this.redis) {
+            throw new Error(REDIS_NOT_STARTED_ERROR);
+        }
+        const key = this.didKey(did);
+        // Update operations in ops store if modified, then strip from events
+        const payloads = [];
+        for (const event of events) {
+            if (event.opid && event.operation) {
+                await this.addOperation(event.opid, event.operation);
+            }
+            const { operation, ...stripped } = event;
+            payloads.push(JSON.stringify(stripped));
+        }
+        await this.runExclusive(async () => {
+            const multi = this.redis.multi().del(key);
+            if (payloads.length) {
+                multi.rpush(key, ...payloads);
+            }
+            await multi.exec();
+        });
+    }
+    didKey(did) {
+        if (!did) {
+            throw new errors.InvalidDIDError();
+        }
+        const id = did.split(':').pop();
+        if (!id) {
+            throw new errors.InvalidDIDError();
+        }
+        return `${this.dbName}/dids/${id}`;
+    }
+    async getEvents(did) {
+        if (!this.redis) {
+            throw new Error(REDIS_NOT_STARTED_ERROR);
+        }
+        const rawEvents = await this.redis.lrange(this.didKey(did), 0, -1);
+        const events = rawEvents.map(event => JSON.parse(event));
+        // Hydrate operations from ops store
+        const hydrated = [];
+        for (const event of events) {
+            if (event.operation) {
+                hydrated.push(event);
+            }
+            else if (event.opid) {
+                const operation = await this.getOperation(event.opid);
+                if (operation) {
+                    hydrated.push({ ...event, operation });
+                }
+                else {
+                    hydrated.push(event);
+                }
+            }
+            else {
+                hydrated.push(event);
+            }
+        }
+        return hydrated;
+    }
+    async deleteEvents(did) {
+        if (!this.redis) {
+            throw new Error(REDIS_NOT_STARTED_ERROR);
+        }
+        if (!did) {
+            throw new errors.InvalidDIDError();
+        }
+        return this.redis.del(this.didKey(did));
+    }
+    async getAllKeys() {
+        if (!this.redis) {
+            throw new Error(REDIS_NOT_STARTED_ERROR);
+        }
+        const keys = await this.redis.keys(`${this.dbName}/dids/*`);
+        // Extract the id part from the key
+        return keys.map(key => key.split('/').pop() || '');
+    }
+    queueKey(registry) {
+        return `${this.dbName}/registry/${registry}/queue`;
+    }
+    async queueOperation(registry, op) {
+        if (!this.redis) {
+            throw new Error(REDIS_NOT_STARTED_ERROR);
+        }
+        const queueKey = this.queueKey(registry);
+        return this.redis.rpush(queueKey, JSON.stringify(op));
+    }
+    async getQueue(registry) {
+        if (!this.redis) {
+            throw new Error(REDIS_NOT_STARTED_ERROR);
+        }
+        try {
+            const queueKey = this.queueKey(registry);
+            const ops = await this.redis.lrange(queueKey, 0, -1);
+            return ops.map(op => JSON.parse(op));
+        }
+        catch {
+            return [];
+        }
+    }
+    async clearQueue(registry, batch) {
+        if (!this.redis) {
+            throw new Error(REDIS_NOT_STARTED_ERROR);
+        }
+        const hashes = batch
+            .map(op => op.signature?.hash)
+            .filter((h) => !!h);
+        if (hashes.length === 0) {
+            return true;
+        }
+        const key = this.queueKey(registry);
+        const script = `
+                      local key = KEYS[1]
+                      local n   = tonumber(ARGV[1])
+                      local idx = 2
+                      local want = {}
+                      for i=1,n do
+                        want[ARGV[idx]] = true
+                        idx = idx + 1
+                      end
+                      local list = redis.call('LRANGE', key, 0, -1)
+                      if #list == 0 then return 0 end
+                      local keep = {}
+                      for i=1,#list do
+                        local ok, obj = pcall(cjson.decode, list[i])
+                        if ok and obj and obj.signature and obj.signature.hash and want[obj.signature.hash] then
+                          -- drop
+                        else
+                          table.insert(keep, list[i])
+                        end
+                      end
+                      redis.call('DEL', key)
+                      if #keep > 0 then
+                        redis.call('RPUSH', key, unpack(keep))
+                      end
+                      return #list - #keep
+                    `;
+        try {
+            await this.redis.eval(script, 1, key, hashes.length.toString(), ...hashes);
+            return true;
+        }
+        catch (e) {
+            console.error(e);
+            return false;
+        }
+    }
+    blockKey(registry, hash) {
+        return `${this.dbName}/registry/${registry}/blocks/${hash}`;
+    }
+    heightMapKey(registry) {
+        return `${this.dbName}/registry/${registry}/heightMap`;
+    }
+    maxHeightKey(registry) {
+        return `${this.dbName}/registry/${registry}/maxHeight`;
+    }
+    operationKey(opid) {
+        return `${this.dbName}/ops/${opid}`;
+    }
+    async addBlock(registry, blockInfo) {
+        if (!this.redis)
+            throw new Error(REDIS_NOT_STARTED_ERROR);
+        const { hash, height } = blockInfo;
+        if (!hash || height == null) {
+            throw new Error(`Invalid blockInfo: ${JSON.stringify(blockInfo)}`);
+        }
+        const blockKey = this.blockKey(registry, hash);
+        const heightMapKey = this.heightMapKey(registry);
+        const maxHeightKey = this.maxHeightKey(registry);
+        const maxHeight = await this.redis.get(maxHeightKey);
+        const currentMaxHeight = maxHeight ? parseInt(maxHeight) : -1;
+        try {
+            await this.redis.multi()
+                .set(blockKey, JSON.stringify(blockInfo))
+                .hset(heightMapKey, height.toString(), hash)
+                .set(maxHeightKey, Math.max(height, currentMaxHeight))
+                .exec();
+        }
+        catch (error) {
+            return false;
+        }
+        return true;
+    }
+    async getBlock(registry, blockId) {
+        if (!this.redis) {
+            throw new Error(REDIS_NOT_STARTED_ERROR);
+        }
+        try {
+            let blockHash;
+            if (blockId === undefined) {
+                // No blockId provided → get latest by max height
+                const maxHeightStr = await this.redis.get(this.maxHeightKey(registry));
+                if (!maxHeightStr)
+                    return null;
+                blockId = parseInt(maxHeightStr);
+            }
+            if (typeof blockId === 'number') {
+                const heightMapKey = this.heightMapKey(registry);
+                blockHash = await this.redis.hget(heightMapKey, blockId.toString());
+            }
+            else {
+                blockHash = blockId;
+            }
+            if (!blockHash)
+                return null;
+            const blockKey = this.blockKey(registry, blockHash);
+            const blockInfo = await this.redis.get(blockKey);
+            return blockInfo ? JSON.parse(blockInfo) : null;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    async addOperation(opid, op) {
+        if (!this.redis) {
+            throw new Error(REDIS_NOT_STARTED_ERROR);
+        }
+        await this.redis.set(this.operationKey(opid), JSON.stringify(op));
+    }
+    async getOperation(opid) {
+        if (!this.redis) {
+            throw new Error(REDIS_NOT_STARTED_ERROR);
+        }
+        const json = await this.redis.get(this.operationKey(opid));
+        return json ? JSON.parse(json) : null;
+    }
+}
+
+exports.default = DbRedis;

package/dist/cjs/db/sqlite.cjs

@@ -0,0 +1,330 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var sqlite = require('sqlite');
+var sqlite3 = require('sqlite3');
+var errors = require('../errors-DQaog-FG.cjs');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var sqlite__namespace = /*#__PURE__*/_interopNamespaceDefault(sqlite);
+
+const SQLITE_NOT_STARTED_ERROR = 'SQLite DB not open. Call start() first.';
+class DbSqlite {
+    dbName;
+    db;
+    constructor(name, dataFolder = 'data') {
+        this.dbName = `${dataFolder}/${name}.db`;
+        this.db = null;
+    }
+    _lock = Promise.resolve();
+    runExclusive(fn) {
+        const run = async () => await fn();
+        const chained = this._lock.then(run, run);
+        this._lock = chained.then(() => undefined, () => undefined);
+        return chained;
+    }
+    async withTx(fn) {
+        if (!this.db) {
+            throw new Error(SQLITE_NOT_STARTED_ERROR);
+        }
+        await this.db.exec('BEGIN IMMEDIATE');
+        try {
+            const result = await fn();
+            await this.db.exec('COMMIT');
+            return result;
+        }
+        catch (e) {
+            try {
+                await this.db.exec('ROLLBACK');
+            }
+            catch { }
+            throw e;
+        }
+    }
+    splitSuffix(did) {
+        if (!did) {
+            throw new errors.InvalidDIDError();
+        }
+        const suffix = did.split(':').pop();
+        if (!suffix) {
+            throw new errors.InvalidDIDError();
+        }
+        return suffix;
+    }
+    async start() {
+        this.db = await sqlite__namespace.open({
+            filename: this.dbName,
+            driver: sqlite3.Database
+        });
+        await this.db.exec(`CREATE TABLE IF NOT EXISTS dids (
+            id TEXT PRIMARY KEY,
+            events TEXT
+        )`);
+        await this.db.exec(`CREATE TABLE IF NOT EXISTS queue (
+            id TEXT PRIMARY KEY,
+            ops TEXT
+        )`);
+        await this.db.exec(`CREATE TABLE IF NOT EXISTS blocks (
+                registry TEXT NOT NULL,
+                hash TEXT NOT NULL,
+                height INTEGER NOT NULL,
+                time TEXT NOT NULL,
+                txns INTEGER NOT NULL,
+                PRIMARY KEY (registry, hash)
+            );
+
+            CREATE UNIQUE INDEX IF NOT EXISTS idx_registry_height ON blocks (registry, height);
+        `);
+        await this.db.exec(`CREATE TABLE IF NOT EXISTS operations (
+            opid TEXT PRIMARY KEY,
+            operation TEXT
+        )`);
+    }
+    async stop() {
+        if (this.db) {
+            await this.db.close();
+            this.db = null;
+        }
+    }
+    async resetDb() {
+        if (!this.db) {
+            throw new Error(SQLITE_NOT_STARTED_ERROR);
+        }
+        await this.runExclusive(async () => {
+            await this.withTx(async () => {
+                await this.db.run('DELETE FROM dids');
+                await this.db.run('DELETE FROM queue');
+                await this.db.run('DELETE FROM blocks');
+                await this.db.run('DELETE FROM operations');
+            });
+        });
+    }
+    async addEvent(did, event) {
+        if (!did) {
+            throw new errors.InvalidDIDError();
+        }
+        return this.runExclusive(() => this.withTx(async () => {
+            const id = this.splitSuffix(did);
+            // Store operation separately if present
+            if (event.opid && event.operation) {
+                await this.addOperationStrict(event.opid, event.operation);
+            }
+            const events = await this.getEventsStrictRaw(id);
+            // Strip operation and store only opid reference
+            const { operation, ...strippedEvent } = event;
+            events.push(strippedEvent);
+            return this.setEventsStrict(id, events);
+        }));
+    }
+    async setEventsStrict(id, events) {
+        if (!this.db) {
+            throw new Error(SQLITE_NOT_STARTED_ERROR);
+        }
+        // Update operations in ops table if modified, then strip from events
+        const strippedEvents = [];
+        for (const event of events) {
+            if (event.opid && event.operation) {
+                await this.addOperationStrict(event.opid, event.operation);
+            }
+            const { operation, ...stripped } = event;
+            strippedEvents.push(stripped);
+        }
+        const res = await this.db.run(`INSERT OR REPLACE INTO dids(id, events) VALUES(?, ?)`, id, JSON.stringify(strippedEvents));
+        return res.changes ?? 0;
+    }
+    async addOperationStrict(opid, op) {
+        if (!this.db) {
+            throw new Error(SQLITE_NOT_STARTED_ERROR);
+        }
+        await this.db.run(`INSERT OR REPLACE INTO operations(opid, operation) VALUES(?, ?)`, opid, JSON.stringify(op));
+    }
+    async setEvents(did, events) {
+        const id = this.splitSuffix(did);
+        return this.runExclusive(() => this.withTx(() => this.setEventsStrict(id, events)));
+    }
+    async getEventsStrictRaw(id) {
+        if (!this.db) {
+            throw new Error(SQLITE_NOT_STARTED_ERROR);
+        }
+        const row = await this.db.get('SELECT events FROM dids WHERE id = ?', id);
+        if (!row) {
+            return [];
+        }
+        const events = JSON.parse(row.events);
+        if (!Array.isArray(events)) {
+            throw new Error('events is not an array');
+        }
+        return events;
+    }
+    async hydrateEvents(events) {
+        const hydrated = [];
+        for (const event of events) {
+            if (event.operation) {
+                hydrated.push(event);
+            }
+            else if (event.opid) {
+                const operation = await this.getOperation(event.opid);
+                if (operation) {
+                    hydrated.push({ ...event, operation });
+                }
+                else {
+                    hydrated.push(event);
+                }
+            }
+            else {
+                hydrated.push(event);
+            }
+        }
+        return hydrated;
+    }
+    async getEvents(did) {
+        if (!this.db) {
+            throw new Error(SQLITE_NOT_STARTED_ERROR);
+        }
+        try {
+            const id = this.splitSuffix(did);
+            const events = await this.getEventsStrictRaw(id);
+            return this.hydrateEvents(events);
+        }
+        catch {
+            return [];
+        }
+    }
+    async deleteEvents(did) {
+        if (!this.db) {
+            throw new Error(SQLITE_NOT_STARTED_ERROR);
+        }
+        return this.runExclusive(() => this.withTx(async () => {
+            const id = this.splitSuffix(did);
+            const result = await this.db.run('DELETE FROM dids WHERE id = ?', id);
+            return result.changes ?? 0;
+        }));
+    }
+    async queueOperation(registry, op) {
+        if (!this.db) {
+            throw new Error(SQLITE_NOT_STARTED_ERROR);
+        }
+        return this.runExclusive(async () => this.withTx(async () => {
+            const ops = await this.getQueueStrict(registry);
+            ops.push(op);
+            await this.db.run(`INSERT OR REPLACE INTO queue(id, ops) VALUES(?, ?)`, registry, JSON.stringify(ops));
+            return ops.length;
+        }));
+    }
+    async getQueueStrict(registry) {
+        if (!this.db) {
+            throw new Error(SQLITE_NOT_STARTED_ERROR);
+        }
+        const row = await this.db.get('SELECT ops FROM queue WHERE id = ?', registry);
+        if (!row) {
+            return [];
+        }
+        const ops = JSON.parse(row.ops);
+        if (!Array.isArray(ops)) {
+            throw new Error('queue row malformed: ops is not an array');
+        }
+        return ops;
+    }
+    async getQueue(registry) {
+        if (!this.db) {
+            throw new Error(SQLITE_NOT_STARTED_ERROR);
+        }
+        try {
+            return await this.getQueueStrict(registry);
+        }
+        catch {
+            return [];
+        }
+    }
+    async clearQueue(registry, batch) {
+        if (!this.db) {
+            throw new Error(SQLITE_NOT_STARTED_ERROR);
+        }
+        return this.runExclusive(async () => this.withTx(async () => {
+            const oldQueue = await this.getQueueStrict(registry);
+            const batchHashes = new Set(batch.map(b => b.signature?.hash).filter((h) => h !== undefined));
+            const newQueue = oldQueue.filter(item => !batchHashes.has(item.signature?.hash || ''));
+            await this.db.run(`INSERT OR REPLACE INTO queue(id, ops) VALUES(?, ?)`, registry, JSON.stringify(newQueue));
+            return true;
+        }).catch(err => {
+            console.error(err);
+            return false;
+        }));
+    }
+    async getAllKeys() {
+        if (!this.db) {
+            throw new Error(SQLITE_NOT_STARTED_ERROR);
+        }
+        const rows = await this.db.all('SELECT id FROM dids');
+        return rows.map(row => row.id);
+    }
+    async addBlock(registry, blockInfo) {
+        if (!this.db) {
+            throw new Error(SQLITE_NOT_STARTED_ERROR);
+        }
+        try {
+            // Insert or replace the block information
+            await this.runExclusive(async () => await this.db.run(`INSERT OR REPLACE INTO blocks (registry, hash, height, time, txns) VALUES (?, ?, ?, ?, ?)`, registry, blockInfo.hash, blockInfo.height, blockInfo.time, 0));
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    async getBlock(registry, blockId) {
+        if (!this.db) {
+            throw new Error(SQLITE_NOT_STARTED_ERROR);
+        }
+        try {
+            let blockRow;
+            if (blockId === undefined) {
+                // Return block with max height
+                blockRow = await this.db.get(`SELECT * FROM blocks WHERE registry = ? ORDER BY height DESC LIMIT 1`, registry);
+            }
+            else if (typeof blockId === 'number') {
+                blockRow = await this.db.get(`SELECT * FROM blocks WHERE registry = ? AND height = ?`, registry, blockId);
+            }
+            else {
+                blockRow = await this.db.get(`SELECT * FROM blocks WHERE registry = ? AND hash = ?`, registry, blockId);
+            }
+            return blockRow ?? null;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    async addOperation(opid, op) {
+        if (!this.db) {
+            throw new Error(SQLITE_NOT_STARTED_ERROR);
+        }
+        await this.runExclusive(() => this.withTx(async () => {
+            await this.db.run(`INSERT OR REPLACE INTO operations(opid, operation) VALUES(?, ?)`, opid, JSON.stringify(op));
+        }));
+    }
+    async getOperation(opid) {
+        if (!this.db) {
+            throw new Error(SQLITE_NOT_STARTED_ERROR);
+        }
+        const row = await this.db.get('SELECT operation FROM operations WHERE opid = ?', opid);
+        return row ? JSON.parse(row.operation) : null;
+    }
+}
+
+exports.default = DbSqlite;

package/dist/cjs/errors-DQaog-FG.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+class ArchonError extends Error {
+    type;
+    detail;
+    constructor(type, detail) {
+        const message = detail ? `${type}: ${detail}` : type;
+        super(message);
+        this.type = type;
+        this.detail = detail;
+    }
+}
+class InvalidDIDError extends ArchonError {
+    static type = 'Invalid DID';
+    constructor(detail) {
+        super(InvalidDIDError.type, detail);
+    }
+}
+class InvalidParameterError extends ArchonError {
+    static type = 'Invalid parameter';
+    constructor(detail) {
+        super(InvalidParameterError.type, detail);
+    }
+}
+class InvalidOperationError extends ArchonError {
+    static type = 'Invalid operation';
+    constructor(detail) {
+        super(InvalidOperationError.type, detail);
+    }
+}
+
+exports.InvalidDIDError = InvalidDIDError;
+exports.InvalidOperationError = InvalidOperationError;
+exports.InvalidParameterError = InvalidParameterError;