@e-mc/db 0.0.2 → 0.0.4

package/redis/index.js

@@ -1,550 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DB_SOURCE_TYPE = exports.DB_SOURCE_CLIENT = exports.checkTimeout = exports.executeBatchQuery = exports.executeQuery = exports.setCredential = void 0;
-const util_1 = require("../util");
-const types_1 = require("../../types");
-const index_1 = require("../index");
-const pool_1 = require("../pool");
-const REDIS_V4 = index_1.default.checkSemVer("redis" /* STRINGS.PACKAGE_NAME */, 4);
-class RedisPool extends pool_1.default {
-    getConnection() {
-        return Promise.resolve(this.client);
-    }
-    close() {
-        return this.client.disconnect();
-    }
-    isEmpty() {
-        return this.closed;
-    }
-    get closed() {
-        return !this.client.isOpen;
-    }
-}
-const POOL_STATE = {};
-function getClient(db, options, poolKey) {
-    const socket = options.socket || (options.socket = {});
-    if (!poolKey) {
-        socket.keepAlive = false;
-    }
-    else if (typeof socket.keepAlive !== 'number') {
-        socket.keepAlive = undefined;
-    }
-    return new Promise((resolve, reject) => {
-        const client = db.createClient(options);
-        if (poolKey) {
-            client.on('end', () => {
-                delete POOL_STATE[poolKey];
-            });
-        }
-        client.connect().then(() => resolve(client)).catch(err => reject(err));
-    });
-}
-const removePoolProperties = (options) => {
-    if (!options.uuidKey && ('socket' in options || 'isolationPoolOptions' in options)) {
-        return { ...options, socket: options.socket?.tls ? { tls: true } : undefined, isolationPoolOptions: undefined };
-    }
-    return options;
-};
-const getPoolKey = (options) => options.url + '_' + (options.username || '') + '_' + (options.password || '') + '_' + (options.database ?? '') + '_' + (options.socket?.tls ? '1' : '0') + '_' + (options.legacyMode ? '1' : '0');
-async function setCredential(item) {
-    if (!REDIS_V4) {
-        throw (0, types_1.errorValue)("Upgrade client to latest version" /* ERR_DB.UPGRADE */, "redis" /* STRINGS.PACKAGE_NAME */ + '@' + index_1.default.getPackageVersion("redis" /* STRINGS.PACKAGE_NAME */));
-    }
-    const credential = this.getCredential(item);
-    const options = item.options || (item.options = {});
-    const client = (0, types_1.isPlainObject)(options.client) ? options.client : options.client = {};
-    let { uri, username, password, database = 0 } = item;
-    if (database > 0) {
-        client.database = database;
-    }
-    if (credential) {
-        const auth = (0, util_1.parseServerAuth)(credential, 6379 /* VALUES.PORT */);
-        if (!client.database) {
-            if ('database' in credential) {
-                const value = credential.database;
-                if (+value > 0) {
-                    database = +value;
-                }
-                delete credential.database;
-            }
-            if (database > 0) {
-                client.database = database;
-            }
-        }
-        uri || (uri = (auth.protocol || 'redis:') + '//' + (auth.server || 'localhost:' + (auth.port ? auth.port : 6379 /* VALUES.PORT */)));
-        username || (username = auth.username);
-        password || (password = auth.password);
-    }
-    else {
-        delete item.credential;
-    }
-    if (!uri) {
-        throw (0, types_1.errorMessage)("redis" /* STRINGS.MODULE_NAME */, 'Not defined - uri');
-    }
-    if (client.socket?.tls) {
-        this.readTLSConfig(client.socket);
-    }
-    client.url = uri;
-    if (username) {
-        client.username = username;
-    }
-    if (password) {
-        client.password = password;
-    }
-    const usePool = item.usePool;
-    if (usePool) {
-        let pool;
-        username = undefined;
-        password = undefined;
-        if (typeof usePool === 'string' && (username = client.username || (0, util_1.parseConnectionString)(uri)?.username)) {
-            [password, pool] = pool_1.default.validateKey(POOL_STATE, username, usePool);
-            if (pool) {
-                pool.add(item, password);
-                return;
-            }
-        }
-        const poolKey = getPoolKey(client);
-        if (!(pool = POOL_STATE[poolKey]) || pool.closed) {
-            const db = require("redis" /* STRINGS.PACKAGE_NAME */);
-            const config = this.getPoolConfig("redis" /* STRINGS.MODULE_NAME */, password);
-            const poolOptions = client.isolationPoolOptions || (client.isolationPoolOptions = {});
-            if (config) {
-                const { min, max, idle, queue_max, queue_idle } = config;
-                if (min >= 0) {
-                    poolOptions.min ?? (poolOptions.min = min);
-                }
-                if (max > 0) {
-                    poolOptions.max ?? (poolOptions.max = max);
-                }
-                if (idle > 0) {
-                    poolOptions.idleTimeoutMillis ?? (poolOptions.idleTimeoutMillis = idle);
-                }
-                if (queue_max >= 0) {
-                    poolOptions.maxWaitingClients ?? (poolOptions.maxWaitingClients = queue_max);
-                }
-                if (queue_idle > 0) {
-                    poolOptions.acquireTimeoutMillis ?? (poolOptions.acquireTimeoutMillis = queue_idle);
-                }
-            }
-            try {
-                const redis = new RedisPool(await getClient(db, client, poolKey), poolKey, username && password ? { username, password } : undefined).add(item);
-                redis.parent = POOL_STATE;
-                redis.success = 1;
-            }
-            catch {
-                item.usePool = false;
-                delete client.isolationPoolOptions;
-            }
-        }
-        else {
-            pool.add(item);
-        }
-    }
-}
-exports.setCredential = setCredential;
-async function executeQuery(item, options) {
-    return (await executeBatchQuery.call(this, [item], options))[0] || [];
-}
-exports.executeQuery = executeQuery;
-async function executeBatchQuery(batch, options = '', outResult) {
-    const length = batch.length;
-    if (length === 0) {
-        return [];
-    }
-    const db = require("redis" /* STRINGS.PACKAGE_NAME */);
-    let parallel, checkObject, connectOnce, errorQuery, sessionKey, outCacheMiss;
-    if ((0, types_1.isPlainObject)(options)) {
-        ({ parallel, checkObject, connectOnce, errorQuery, sessionKey, outCacheMiss } = options);
-    }
-    else {
-        if (typeof options === 'string') {
-            sessionKey = options;
-        }
-        options = undefined;
-    }
-    if (length === 1) {
-        connectOnce = false;
-        parallel = false;
-    }
-    else if (parallel === undefined) {
-        parallel = !batch.some(item => item.parallel === false);
-    }
-    if (!parallel) {
-        outResult || (outResult = new Array(length));
-    }
-    const caching = this.hasCache("redis" /* STRINGS.MODULE_NAME */, sessionKey);
-    const tasks = new Array(length);
-    const clients = [];
-    let redisClient, redisCredential, redisCache = 0, onceCredential = connectOnce ? batch[0].options?.client : undefined;
-    const getConnection = async (item, credential) => {
-        item.transactionState = 64 /* TRANSACTION_DB.AUTH */;
-        let client;
-        if (item.usePool) {
-            const pool = pool_1.default.findKey(POOL_STATE, item.usePool, getPoolKey(credential), ...connectOnce ? [item, batch[0]] : [item]);
-            if (pool) {
-                client = pool.client;
-                pool.connected = true;
-            }
-        }
-        if (!client) {
-            if (connectOnce && parallel) {
-                const size = length - redisCache;
-                if (size > 1) {
-                    (credential.isolationPoolOptions || (credential.isolationPoolOptions = {})).max = size;
-                }
-            }
-            clients.push(client = await getClient(db, credential));
-        }
-        if (connectOnce) {
-            redisClient = client;
-            redisCredential = credential;
-        }
-        item.transactionState &= ~64 /* TRANSACTION_DB.AUTH */;
-        return client;
-    };
-    for (let i = 0; i < length; ++i) {
-        const item = batch[i];
-        const { source, uri, key, format = 'HASH', search, update, options: clientOptions = {}, cacheObjectKey, ignoreCache } = item;
-        let credential = (redisCredential || onceCredential), error;
-        if (!credential && !(0, types_1.isPlainObject)(credential = clientOptions.client) && (error = (0, types_1.errorMessage)(source, "Invalid credentials" /* ERR_DB.CREDENTIALS */)) || !((0, types_1.isString)(key) || (0, types_1.isArray)(key) || (0, types_1.isPlainObject)(search) && ((0, types_1.isPlainObject)(search.schema) || (0, types_1.isString)(search.query))) && (error = (0, types_1.errorMessage)(source, "Missing database query" /* ERR_DB.QUERY */, uri))) {
-            ++redisCache;
-            if (this.handleFail(error, item, { errorQuery })) {
-                if (!parallel) {
-                    tasks.length = 0;
-                    break;
-                }
-                tasks[i] = Promise.reject(error);
-            }
-            else if (parallel) {
-                tasks[i] = Promise.resolve([]);
-            }
-            else {
-                outResult[i] = [];
-            }
-            continue;
-        }
-        item.transactionState = 1 /* TRANSACTION_DB.ACTIVE */;
-        const uuidKey = (credential.uuidKey || (credential.uuidKey = (onceCredential ? batch[0] : item).credential?.uuidKey));
-        const targetObject = typeof checkObject === 'string' ? this.hasCoerce("redis" /* STRINGS.MODULE_NAME */, 'options', uuidKey) && (0, types_1.asFunction)(checkObject) : checkObject;
-        const renewCache = ignoreCache === 0;
-        const cacheValue = renewCache ? { sessionKey, renewCache } : sessionKey;
-        const command = (0, types_1.isPlainObject)(clientOptions.command) ? db.commandOptions(clientOptions.command) : null;
-        let queryString = '', rows;
-        if (caching && ignoreCache !== true || ignoreCache === false || ignoreCache === 1 || renewCache) {
-            if ((0, types_1.isObject)(search)) {
-                queryString = index_1.default.asString(search, true);
-            }
-            else if (!targetObject) {
-                queryString = index_1.default.asString(key);
-            }
-            else if (cacheObjectKey) {
-                queryString = index_1.default.asString(key) + '_' + targetObject.toString() + cacheObjectKey;
-            }
-            if (queryString) {
-                queryString += '_' + format;
-            }
-            if (ignoreCache !== 1) {
-                if (rows = this.getQueryResult(source, removePoolProperties(credential), queryString, cacheValue)) {
-                    ++redisCache;
-                    if (parallel) {
-                        tasks[i] = Promise.resolve(rows);
-                    }
-                    else {
-                        outResult[i] = rows;
-                    }
-                    this.add(item, 4 /* TRANSACTION_DB.COMMIT */ | 128 /* TRANSACTION_DB.CACHE */);
-                    continue;
-                }
-                if (!ignoreCache && outCacheMiss) {
-                    outCacheMiss.push(source);
-                }
-            }
-        }
-        if (onceCredential && parallel) {
-            try {
-                redisClient = await getConnection(item, onceCredential);
-            }
-            catch {
-                connectOnce = false;
-                parallel = false;
-            }
-            onceCredential = undefined;
-        }
-        tasks[i] = new Promise(async (resolve, reject) => {
-            let commandType;
-            try {
-                const client = redisClient || await getConnection(item, credential);
-                const a = (arg) => typeof arg === 'string' || Buffer.isBuffer(arg) || typeof arg === 'number';
-                const b = (arg) => typeof arg === 'number' || Buffer.isBuffer(arg) ? arg.toString() : arg;
-                if (update) {
-                    commandType = this.commandType.UPDATE;
-                    const values = (!Array.isArray(update) ? [update] : update).map(target => {
-                        return new Promise(async (success, failed) => {
-                            let { key: k, value: v, format: f = 'HASH', NX, XX, EX = 0, PX = 0, EXAT = 0, PXAT = 0, options: setOptions = {} } = target;
-                            if (v === undefined) {
-                                success(target);
-                                return;
-                            }
-                            const failKey = () => failed((0, types_1.errorMessage)(f, "Invalid key" /* ERR_DB.KEY */, index_1.default.asString(k) || "Unknown" /* ERR_MESSAGE.UNKNOWN */));
-                            const failValue = () => failed((0, types_1.errorMessage)(f, "Invalid value" /* ERR_DB.VALUE */, index_1.default.asString(v) || "Unknown" /* ERR_MESSAGE.UNKNOWN */));
-                            const commandSet = (0, types_1.isPlainObject)(setOptions.command) && db.commandOptions(setOptions.command);
-                            let pending;
-                            if ((f = f.toUpperCase()) === 'JSON') {
-                                if (typeof k !== 'string') {
-                                    failKey();
-                                    return;
-                                }
-                                const path = target.path || '$';
-                                if (this.hasCoerce("redis" /* STRINGS.MODULE_NAME */, 'options', uuidKey)) {
-                                    if ((0, types_1.isString)(v) && v.startsWith('new')) {
-                                        ({ outV: v } = (0, types_1.coerceObject)({ outV: v }));
-                                    }
-                                }
-                                const flags = NX ? { NX } : XX ? { XX } : undefined;
-                                pending = commandSet ? client.json.set(commandSet, k, path, v, flags) : client.json.set(k, path, v, flags);
-                            }
-                            else if (typeof k === 'string' || Buffer.isBuffer(k)) {
-                                const field = target.field;
-                                if (field === undefined && field === null) {
-                                    if (a(v)) {
-                                        const flags = setOptions.set;
-                                        if (flags) {
-                                            if ('NX' in flags) {
-                                                NX ?? (NX = !!flags.NX);
-                                                delete flags.NX;
-                                            }
-                                            if ('XX' in flags) {
-                                                XX ?? (XX = !!flags.XX);
-                                                delete flags.XX;
-                                            }
-                                            if ('EX' in flags) {
-                                                EX || (EX = flags.EX);
-                                                delete flags.EX;
-                                            }
-                                            if ('PX' in flags) {
-                                                PX || (PX = flags.PX);
-                                                delete flags.PX;
-                                            }
-                                            if ('EXAT' in flags) {
-                                                EXAT || (EXAT = flags.EXAT);
-                                                delete flags.EXAT;
-                                            }
-                                            if ('PXAT' in flags) {
-                                                PXAT || (PXAT = flags.PXAT);
-                                                delete flags.PXAT;
-                                            }
-                                        }
-                                        pending = (commandSet ? client.set(commandSet, k, v, setOptions.set) : client.set(k, v, setOptions.set));
-                                    }
-                                    else if (typeof v === 'object') {
-                                        let valid = true;
-                                        if (NX || XX) {
-                                            valid = await client.exists(k) === 1;
-                                            if (NX) {
-                                                valid = !valid;
-                                            }
-                                        }
-                                        if (!valid) {
-                                            success(target);
-                                            return;
-                                        }
-                                        pending = commandSet ? client.hSet(commandSet, k, v) : client.hSet(k, v);
-                                    }
-                                }
-                                else if (NX) {
-                                    if (a(field) && a(v)) {
-                                        pending = commandSet ? client.hSetNX(commandSet, k, b(field), b(v)) : client.hSetNX(k, b(field), b(v));
-                                    }
-                                }
-                                else {
-                                    let valid = true;
-                                    if (XX) {
-                                        valid = a(k) && a(field) && await client.hExists(b(k), b(field));
-                                    }
-                                    if (a(field) && a(v)) {
-                                        if (!valid) {
-                                            success(target);
-                                            return;
-                                        }
-                                        pending = commandSet ? client.hSet(commandSet, k, field, v) : client.hSet(k, field, v);
-                                    }
-                                }
-                            }
-                            else {
-                                failKey();
-                                return;
-                            }
-                            if (pending) {
-                                pending.then(code => {
-                                    if (code === 'OK' || typeof code === 'number' || code === true) {
-                                        const has = (n) => typeof n === 'number' && n !== 0;
-                                        if (has(EX) || has(PX) || EXAT > 0 || PXAT > 0) {
-                                            const expire = setOptions.expire;
-                                            let mode;
-                                            if (expire) {
-                                                if (expire.NX) {
-                                                    mode = 'NX';
-                                                }
-                                                else if (expire.XX) {
-                                                    mode = 'XX';
-                                                }
-                                                else if (expire.GT) {
-                                                    mode = 'GT';
-                                                }
-                                                else if (expire.LT) {
-                                                    mode = 'LT';
-                                                }
-                                            }
-                                            (has(EX) ? client.expire(k, EX, mode) : has(PX) ? client.pExpire(k, PX, mode) : EXAT > 0 ? client.expireAt(k, EXAT, mode) : client.pExpireAt(k, PXAT, mode))
-                                                .then(valid => {
-                                                if (valid) {
-                                                    success(target);
-                                                }
-                                                else {
-                                                    failed((0, types_1.errorMessage)(f, "Invalid value" /* ERR_DB.VALUE */, has(EX) ? 'EX: ' + EX : has(PX) ? 'PX: ' + PX : EXAT > 0 ? 'EXAT: ' + EX : 'PXAT: ' + PXAT));
-                                                }
-                                            })
-                                                .catch(err => failed(err));
-                                        }
-                                        else {
-                                            success(target);
-                                        }
-                                    }
-                                    else {
-                                        failValue();
-                                    }
-                                })
-                                    .catch(err => failed(err));
-                            }
-                            else {
-                                failValue();
-                            }
-                        });
-                    });
-                    await Promise.allSettled(values)
-                        .then(result => {
-                        for (const cmd of result) {
-                            if (cmd.status === 'rejected' && this.handleFail(cmd.reason, item, { errorQuery, commandType })) {
-                                reject(cmd.reason);
-                                break;
-                            }
-                        }
-                    })
-                        .catch(err => {
-                        if (this.handleFail(err, item, { errorQuery, commandType })) {
-                            reject(err);
-                        }
-                    });
-                }
-                commandType = this.commandType.SELECT;
-                if ((0, types_1.isObject)(search)) {
-                    const { query = '', schema, index } = search;
-                    let idx = '';
-                    if ((0, types_1.isObject)(schema)) {
-                        idx = index || (0, types_1.generateUUID)();
-                        await (command ? client.ft.create(command, idx, schema, search.options) : client.ft.create(idx, schema, search.options));
-                    }
-                    try {
-                        const reply = await (command ? client.ft.search(command, index || idx, query) : client.ft.search(index || idx, query));
-                        rows = reply.documents.map(doc => (doc.value['__id__'] = doc.id) && doc.value);
-                    }
-                    catch (err) {
-                        error = err;
-                    }
-                    if (idx && idx !== index) {
-                        client.ft.dropIndex(idx).catch(err => this.writeFail(['Unable to drop search index', idx], err, { type: 65536 /* LOG_TYPE.DB */, fatal: false }));
-                    }
-                    if (error instanceof Error) {
-                        throw error;
-                    }
-                }
-                else if (key) {
-                    let data;
-                    if (Array.isArray(key)) {
-                        switch (format.toUpperCase()) {
-                            case 'HKEYS':
-                                data = await Promise.all(key.map(k => client.hKeys(...command ? [command, k] : [k])));
-                                break;
-                            case 'HVALS':
-                                data = await Promise.all(key.map(k => client.hVals(...command ? [command, k] : [k])));
-                                break;
-                            case 'JSON':
-                                data = (await (command ? client.json.mGet(command, key.map(c => b(c)), item.path || '$') : client.json.mGet(key.map(c => b(c)), item.path || '$'))).flat();
-                                break;
-                            default:
-                                data = await client.mGet(...command ? [command, key] : [key]);
-                                break;
-                        }
-                    }
-                    else {
-                        switch (format.toUpperCase()) {
-                            case 'HKEYS':
-                                data = await client.hKeys(...command ? [command, key] : [key]);
-                                break;
-                            case 'HVALS':
-                                data = await client.hVals(...command ? [command, key] : [key]);
-                                break;
-                            case 'JSON':
-                                data = await (clientOptions.get ? client.json.get(...command ? [command, b(key), clientOptions.get] : [b(key), clientOptions.get]) : client.json.get(...command ? [command, b(key)] : [b(key)]));
-                                break;
-                            default:
-                                if (item.field) {
-                                    data = client.hGet(...command ? [command, key, item.field] : [key, item.field]);
-                                }
-                                else {
-                                    data = await client.hGetAll(...command ? [command, key] : [key]);
-                                }
-                                break;
-                        }
-                    }
-                    rows = (targetObject ? targetObject(item, data) : data);
-                }
-                if (rows === undefined) {
-                    throw (0, types_1.errorMessage)(source, "Missing database query" /* ERR_DB.QUERY */);
-                }
-                this.add(item, 4 /* TRANSACTION_DB.COMMIT */);
-                resolve(this.setQueryResult(source, removePoolProperties(redisCredential || credential), queryString, rows, cacheValue));
-            }
-            catch (err) {
-                if (err instanceof Error) {
-                    switch (err.message) {
-                        case "The client is closed" /* STRINGS.ERR_CLIENT_CLOSE */:
-                        case "Disconnects client" /* STRINGS.ERR_CLIENT_DISCONNECT */: {
-                            const pool = item.usePool && pool_1.default.findKey(POOL_STATE, item.usePool, getPoolKey(credential));
-                            if (pool) {
-                                await pool.detach(true);
-                            }
-                            break;
-                        }
-                    }
-                }
-                if (this.handleFail(err, item, { errorQuery, commandType })) {
-                    reject(err);
-                }
-                else {
-                    resolve([]);
-                }
-            }
-        });
-        if (!parallel) {
-            try {
-                outResult[i] = await tasks[i];
-            }
-            catch {
-                tasks.length = 0;
-                break;
-            }
-        }
-    }
-    return this.processRows(batch, tasks, {
-        disconnect: () => clients.forEach(item => item.disconnect()),
-        parallel
-    }, outResult);
-}
-exports.executeBatchQuery = executeBatchQuery;
-function checkTimeout(value, limit = 0) {
-    return pool_1.default.checkTimeout(POOL_STATE, value, limit);
-}
-exports.checkTimeout = checkTimeout;
-exports.DB_SOURCE_CLIENT = true;
-exports.DB_SOURCE_TYPE = types_1.DB_TYPE.NOSQL | types_1.DB_TYPE.KEYVALUE;