immudb-node/dist/src/state.js

Node.js SDK for immudb written in TypeScript

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const fs_1 = __importDefault(require("fs"));
const schemaTypes = __importStar(require("./proto/schema_pb"));
const empty = __importStar(require("google-protobuf/google/protobuf/empty_pb"));
var Signals;
(function (Signals) {
    Signals["EXIT"] = "exit";
    Signals["SIGINT"] = "SIGINT";
    Signals["UNCAUGHT_EXCEPTION"] = "uncaughtException";
})(Signals || (Signals = {}));
class State {
    constructor({ client, rootPath = 'root' }) {
        const handleExit = () => {
            this.exitHandler();
        };
        process.on(Signals.EXIT, handleExit);
        process.on(Signals.SIGINT, handleExit);
        process.on(Signals.UNCAUGHT_EXCEPTION, handleExit);
        this.client = client;
        this.rootPath = rootPath;
        this.servers = this.getInitialState();
    }
    async get(config) {
        const { serverName, databaseName } = config;
        const server = this.servers[serverName];
        if (server !== undefined) {
            const state = server[databaseName];
            if (state !== undefined || Object.keys(state).length === 0) {
                const { db, txid, txhash, signature } = state;
                const iState = new schemaTypes.ImmutableState();
                iState.setDb(db);
                iState.setTxid(txid);
                iState.setTxhash(txhash);
                if (signature !== undefined) {
                    const sgntr = new schemaTypes.Signature();
                    sgntr.setSignature(signature.signature);
                    sgntr.setPublickey(signature.publickey);
                    iState.setSignature(sgntr);
                }
                return iState;
            }
            else {
                return await this.getCurrentState(config);
            }
        }
        else {
            return await this.getCurrentState(config);
        }
    }
    async getCurrentState(config) {
        const { databaseName, metadata } = config;
        return new Promise((resolve, reject) => this.client.currentState(new empty.Empty(), metadata, (err, res) => {
            if (err) {
                reject(err);
            }
            const stateObject = {
                db: res.getDb(),
                txid: res.getTxid(),
                txhash: res.getTxhash_asU8(),
                signature: res.getSignature()?.toObject()
            };
            const state = new schemaTypes.ImmutableState();
            const sgntr = new schemaTypes.Signature();
            if (stateObject.signature !== undefined) {
                sgntr.setSignature(stateObject.signature.signature);
                sgntr.setPublickey(stateObject.signature.publickey);
            }
            state.setDb(databaseName);
            state.setTxid(stateObject.txid);
            state.setTxhash(stateObject.txhash);
            state.setSignature(sgntr);
            this.set(config, stateObject);
            resolve(state);
        }));
    }
    set({ serverName, databaseName }, state) {
        const server = this.servers[serverName] || {};
        server[databaseName] = state;
        this.servers[serverName] = server;
        this.commit();
    }
    getInitialState() {
        try {
            if (fs_1.default.existsSync(this.rootPath)) {
                const rawdata = fs_1.default.readFileSync(this.rootPath, 'utf-8');
                return this.parseServers(rawdata);
            }
            else {
                return {};
            }
        }
        catch (err) {
            console.error(err);
            throw new Error('Error getting initial state');
        }
    }
    commit() {
        try {
            const data = this.stringifyServers();
            fs_1.default.writeFileSync(this.rootPath, data);
        }
        catch (err) {
            console.error(err);
        }
    }
    exitHandler() {
        this.commit();
    }
    stringifyServers() {
        const serverNames = Object.keys(this.servers);
        const servers = serverNames.reduce((sAcc, serverName) => {
            const databaseNames = Object.keys(this.servers[serverName]);
            const databases = databaseNames.reduce((dAcc, databaseName) => {
                const state = this.servers[serverName][databaseName];
                const txhash = Array.from(state.txhash);
                const newState = Object.assign({}, state, { txhash });
                return Object.assign({}, dAcc, { [databaseName]: newState });
            }, {});
            return Object.assign({}, sAcc, { [serverName]: databases });
        }, {});
        return JSON.stringify(servers);
    }
    parseServers(stringifiedServers) {
        const data = JSON.parse(stringifiedServers);
        const serverNames = Object.keys(data);
        const servers = serverNames.reduce((sAcc, serverName) => {
            const databaseNames = Object.keys(data[serverName]);
            const databases = databaseNames.reduce((dAcc, databaseName) => {
                const state = data[serverName][databaseName];
                const txhash = new Uint8Array(state.txhash);
                const newState = Object.assign({}, state, { txhash });
                return Object.assign({}, dAcc, { [databaseName]: newState });
            }, {});
            return Object.assign({}, sAcc, { [serverName]: databases });
        }, {});
        return servers;
    }
}
exports.default = State;
//# sourceMappingURL=state.js.map