@e-mc/db 0.0.1

package/redis/index.js

@@ -0,0 +1,550 @@
+"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.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.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.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.COMMIT */ | 128 /* TRANSACTION.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.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;

package/types.d.ts

@@ -0,0 +1,14 @@
+import type { DbDataSource } from '../types/lib/squared';
+
+import type { IDb } from '../types/lib';
+import type { BatchQueryResult, ExecuteBatchQueryOptions, ExecuteQueryOptions, QueryResult } from '../types/lib/db';
+
+export interface IDbSourceClient<T extends DbDataSource = DbDataSource> {
+    DB_SOURCE_NAME: string;
+    DB_SOURCE_CLIENT: boolean;
+    DB_SOURCE_TYPE: number;
+    setCredential(this: IDb, item: T): Promise<void>;
+    executeQuery(this: IDb, item: T, options?: ExecuteQueryOptions | string): Promise<QueryResult>;
+    executeBatchQuery(this: IDb, batch: T[], options?: ExecuteBatchQueryOptions | string, outResult?: BatchQueryResult): Promise<BatchQueryResult>;
+    checkTimeout?(this: IDbSourceClient, value: number, limit?: number): Promise<number>;
+}

package/util.d.ts

@@ -0,0 +1,17 @@
+import type { DbDataSource } from '../types/lib/squared';
+
+import type { SQL_COMMAND, DbConnection, ServerAuth } from '../types/lib/db';
+
+declare namespace util {
+    const SQL_COMMAND: SQL_COMMAND;
+    function getBasicAuth(auth: AuthValue): string;
+    function getBasicAuth(username: unknown, password?: unknown): string;
+    function hasBasicAuth(value: string): boolean;
+    function parseConnectionString(value: string, scheme?: string): Null<DbConnection>;
+    function parseServerAuth(value: ServerAuth, all: boolean): ServerAuth;
+    function parseServerAuth(value: ServerAuth, port?: number, all?: boolean): ServerAuth;
+    function checkEmpty(value: unknown): boolean;
+    function setUUIDKey(item: DbDataSource, value: unknown): void;
+}
+
+export = util;