immudb-node
Version:
Node.js SDK for immudb written in TypeScript
180 lines • 8.15 kB
JavaScript
;
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;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.isString = exports.bitLength = exports.withLeafPrefix = exports.encodeZAdd = exports.encodeKeyValue = exports.encodeReferenceValue = exports.prefixValue = exports.prefixKey = exports.maskString = exports.maskConfig = exports.isPowerOfTwo = exports.equalArray = exports.utf8Decode = exports.doubleToByteArray = exports.encodeInt32 = exports.encodeInt64 = exports.getAlh = exports.digestKeyValue = exports.utf8Encode = exports.hashUint8Array = void 0;
const crypto = __importStar(require("crypto"));
const util = __importStar(require("util"));
const schemaTypes = __importStar(require("./proto/schema_pb"));
const consts_1 = require("./consts");
exports.hashUint8Array = (value) => new Uint8Array(crypto.createHash('sha256').update(value).digest());
exports.utf8Encode = (val) => {
return new util.TextEncoder().encode(val);
};
exports.digestKeyValue = (kv) => {
let valdigest;
const key = kv.getKey_asU8();
const value = kv.getValue_asU8();
if (value === undefined) {
valdigest = exports.hashUint8Array(exports.utf8Encode(''));
}
else {
valdigest = exports.hashUint8Array(value);
}
const res = new Uint8Array(key.length + valdigest.length);
res.set(key);
res.set(valdigest, key.length);
return exports.hashUint8Array(res);
};
exports.getAlh = (txm) => {
const encId = exports.encodeInt64(txm.getId());
const prevalh = txm.getPrevalh_asU8();
const encTs = exports.encodeInt64(txm.getTs());
const encEntries = exports.encodeInt32(txm.getNentries());
const eh = txm.getEh_asU8();
const encBltxid = exports.encodeInt64(txm.getBltxid());
const root = txm.getBlroot_asU8();
const bj = new Uint8Array(encTs.length + encEntries.length + eh.length + encBltxid.length + root.length);
bj.set(encTs);
bj.set(encEntries, encTs.length);
bj.set(eh, encTs.length + encEntries.length);
bj.set(encBltxid, encTs.length + encEntries.length + eh.length);
bj.set(root, encTs.length + encEntries.length + eh.length + encBltxid.length);
const innerHash = exports.hashUint8Array(bj);
const bi = new Uint8Array(encId.length + prevalh.length + innerHash.length);
bi.set(encId);
bi.set(prevalh, encId.length);
bi.set(innerHash, encId.length + prevalh.length);
return exports.hashUint8Array(bi);
};
exports.encodeInt64 = (num, buf = Buffer.allocUnsafe(8), offset = 0) => {
const UINT_32_MAX = Math.pow(2, 32);
const top = Math.floor(num / UINT_32_MAX);
const rem = num - top * UINT_32_MAX;
buf.writeUInt32BE(top, offset);
buf.writeUInt32BE(rem, offset + 4);
return buf;
};
exports.encodeInt32 = (num, buf = Buffer.allocUnsafe(4), offset = 0) => {
buf.writeUInt32BE(num, offset);
return buf;
};
exports.doubleToByteArray = (number) => {
var buffer = new ArrayBuffer(8); // JS numbers are 8 bytes long, or 64 bits
var longNum = new Float64Array(buffer); // so equivalent to Float64
longNum[0] = number;
return Array.from(new Int8Array(buffer)).reverse(); // reverse to get little endian
};
exports.utf8Decode = (val) => {
return val === ''
? val
: new util.TextDecoder("utf-8").decode(val);
};
exports.equalArray = (a1, a2) => {
if (a1.length != a2.length) {
return false;
}
for (let i = 0; i < a1.length; i++) {
if (a1[i] != a2[i]) {
return false;
}
}
return true;
};
exports.isPowerOfTwo = (x) => {
return Math.log2(x) % 1 === 0;
};
exports.maskConfig = (c) => {
let result = '';
if (c) {
result += `[ address: ${c.host}:${c.port}`;
c.user && (result += `, user: ${c.user}`);
c.password && (result += ', password: *****');
c.database && (result += `, database: ${c.database || 'defaultdb'}`);
c.rootPath && (result += `, rootPath: ${c.rootPath}`);
c.secure && (result += `, secure: ${!!c.secure}`);
c.certs && (result += `, certs: ${c.certs}`);
c.autoLogin && (result += `, autoLogin: ${!!c.autoLogin}`);
c.autoDatabase && (result += `, autoDatabase: ${!!c.autoDatabase}`);
}
return `${result} ]`;
};
exports.maskString = (data, n = 12) => {
if (data) {
return `${data.slice(0, n)}************${data.slice(data.length - n)}`;
}
return '';
};
exports.prefixKey = (key) => {
const res = new Uint8Array(consts_1.SET_KEY_PREFIX.length + key.length);
res.set(consts_1.SET_KEY_PREFIX);
res.set(key, consts_1.SET_KEY_PREFIX.length);
return res;
};
exports.prefixValue = (value) => {
const res = new Uint8Array(consts_1.PLAIN_VALUE_PREFIX.length + value.length);
res.set(consts_1.PLAIN_VALUE_PREFIX);
res.set(value, consts_1.PLAIN_VALUE_PREFIX.length);
return res;
};
exports.encodeReferenceValue = (referencedKey, atTx) => {
const atTxUint = exports.encodeInt64(atTx);
const encoded = new Uint8Array(consts_1.REFERENCE_VALUE_PREFIX.length + atTxUint.length + consts_1.SET_KEY_PREFIX.length + referencedKey.length);
encoded.set(consts_1.REFERENCE_VALUE_PREFIX);
encoded.set(atTxUint, consts_1.REFERENCE_VALUE_PREFIX.length);
encoded.set(consts_1.SET_KEY_PREFIX, consts_1.REFERENCE_VALUE_PREFIX.length + atTxUint.length);
encoded.set(referencedKey, consts_1.REFERENCE_VALUE_PREFIX.length + atTxUint.length + consts_1.SET_KEY_PREFIX.length);
return encoded;
};
exports.encodeKeyValue = (key, value) => {
const kv = new schemaTypes.KeyValue();
kv.setKey(exports.prefixKey(key));
kv.setValue(exports.prefixValue(value));
return kv;
};
exports.encodeZAdd = (zSet, score, key, attx) => {
const eKey = exports.prefixKey(key);
const zSetLengthUint = exports.encodeInt64(zSet.length);
const scoreUint = exports.doubleToByteArray(score);
const eKeyLengthUint = exports.encodeInt64(eKey.length);
const attxUint = exports.encodeInt64(attx);
const zKey = new Uint8Array(consts_1.SORTED_KEY_PREFIX.length + zSetLengthUint.length + zSet.length + scoreUint.length + eKeyLengthUint.length + eKey.length + attxUint.length);
zKey.set(consts_1.SORTED_KEY_PREFIX);
zKey.set(zSetLengthUint, consts_1.SORTED_KEY_PREFIX.length);
zKey.set(zSet, consts_1.SORTED_KEY_PREFIX.length + zSetLengthUint.length);
zKey.set(scoreUint, consts_1.SORTED_KEY_PREFIX.length + zSetLengthUint.length + zSet.length);
zKey.set(eKeyLengthUint, consts_1.SORTED_KEY_PREFIX.length + zSetLengthUint.length + zSet.length + scoreUint.length);
zKey.set(eKey, consts_1.SORTED_KEY_PREFIX.length + zSetLengthUint.length + zSet.length + scoreUint.length + eKeyLengthUint.length);
zKey.set(attxUint, consts_1.SORTED_KEY_PREFIX.length + zSetLengthUint.length + zSet.length + scoreUint.length + eKeyLengthUint.length + eKey.length);
const kv = new schemaTypes.KeyValue();
kv.setKey(zKey);
return kv;
};
exports.withLeafPrefix = (value) => {
const res = new Uint8Array(consts_1.LEAF_PREFIX.length + value.length);
res.set(consts_1.LEAF_PREFIX);
res.set(value, consts_1.LEAF_PREFIX.length);
return res;
};
exports.bitLength = (n) => n === 0 ? 0 : Math.abs(n).toString(2).length;
exports.isString = (value) => {
return typeof value === 'string';
};
//# sourceMappingURL=util.js.map