react-native-mosquito-transport 0.0.21 → 0.0.22

package/README.md

@@ -19,14 +19,11 @@ yarn add react-native-mosquito-transport
 ```js
 import RNMosquitoTransport from "react-native-mosquito-transport";
 
-RNMosquitoTransport.initializeCache({
-  cachePassword: "****",
-  cacheProtocol: "sqlite",
-});
+// uses sqlite to cache it data by default
+RNMosquitoTransport.initializeCache();
 
 const mclient = new RNMosquitoTransport({
-  projectUrl: "http://localhost:3444",
-  accessKey: "SERVER_ACCESS_KEY",
+  projectUrl: "http://localhost:3444"
 });
 ```
 
@@ -37,7 +34,6 @@ const mclient = new RNMosquitoTransport({
   - [dbUrl](#dbUrl)
   - [projectUrl](#projectUrl)
   - [disableCache](#disableCache)
-  - [accessKey](#accessKey)
   - [maxRetries](#maxRetries)
   - [enableE2E_Encryption](#enableE2E_Encryption)
   - [serverE2E_PublicKey](#serverE2E_PublicKey)

package/TODO

@@ -1,13 +1,23 @@
-- fix local cache query on sqlite and fs
+- fix local cache query on sqlite ✅
 - fix and add all mongodb query and update operator
 - reauthenticate
 - change `Object` in d.ts to [key: string]: any
 - add `getServerTimeOffset` method
-- change null to undefined in `value`
-- `provide functionality to add extra header to MT instance (all outgoing request)`
+- change undefined to null in `value` ✅
+- `provide functionality to add extra header to MT instance (all outgoing request)` ✅
 - borrowToken
-- `add sqlite`
-- minimize extraction data
-- change `collection().onDisconnect()` to `collection().socket().onDisconnect()` and `collection().socket().onConnect()`
-- add `_foreign_doc` to d.ts
-- tree shake dependencies
+- `add sqlite` ✅
+- minimize extraction data ✅
+- change `collection().onDisconnect()` to `collection().socket().onDisconnect()` and `collection().socket().onConnect()` ✅
+- add `_foreign_doc` to d.ts ✅
+- tree shake dependencies
+- dynamic import for fs ✅
+- new URL() work around ✅
+- fetchHttp, default retrieval if has body ✅
+- native hashing
+- TextEncoder
+- native storage upload
+- lodashes ✅
+- switch to events package
+- serverTimeOffset
+<!-- - error: "refreshToken retry limit exceeded" <--- no need -->

package/ios/Mosquitodb.swift

@@ -88,7 +88,6 @@ class MosquitodbUploadTask: NSObject, URLSessionDataDelegate {
         let filepath = options["file"] as! String
         let url = options["url"] as! String
         let destination = options["destination"] as! String
-        let authorization = options["authorization"] as! String
         
         do {
             let rawData = try Data(contentsOf: URL(fileURLWithPath: filepath))
@@ -102,7 +101,6 @@ class MosquitodbUploadTask: NSObject, URLSessionDataDelegate {
                 }
             }
             request.setValue("application/json", forHTTPHeaderField: "Accept")
-            request.setValue(authorization, forHTTPHeaderField: "Authorization")
             if options["authToken"] != nil {
                 request.setValue(options["authToken"] as? String, forHTTPHeaderField: "Mosquito-Token")
             }
@@ -190,7 +188,6 @@ class MosquitodbDownloadTask: NSObject, URLSessionDownloadDelegate {
     func downloadFile(options: [String: Any], completion: @escaping ([Any]?)->()) -> Void {
         let processID = options["processID"] as! String
         let url = options["url"] as! String
-        let authorization = options["authorization"] as! String
         
         var request = URLRequest(url: URL(string: url)!)
         request.httpMethod = "POST"
@@ -200,7 +197,6 @@ class MosquitodbDownloadTask: NSObject, URLSessionDownloadDelegate {
                 request.setValue(value, forHTTPHeaderField: key)
             }
         }
-        request.setValue(authorization, forHTTPHeaderField: "Authorization")
         if options["authToken"] != nil {
             request.setValue(options["authToken"] as? String, forHTTPHeaderField: "Mosquito-Token")
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-mosquito-transport",
-  "version": "0.0.21",
+  "version": "0.0.22",
   "description": "React native javascript sdk for mosquito-transport (https://github.com/brainbehindx/mosquito-transport)",
   "main": "src/index.js",
   "type": "module",
@@ -30,14 +30,11 @@
     "@turf/turf": "^7.1.0",
     "bson": "^6.8.0",
     "buffer": "^6.0.3",
-    "crypto-js": "^4.2.0",
     "entity-serializer": "^1.0.2",
-    "guard-object": "^1.1.3",
-    "lodash.clonedeep": "^4.5.0",
-    "lodash.get": "^4.4.2",
-    "lodash.set": "^4.3.2",
-    "lodash.unset": "^4.5.2",
+    "guard-object": "^1.1.4",
+    "lodash": "^4.17.21",
     "react-native-get-random-values": "^1.9.0",
+    "react-native-hash": "^3.0.3",
     "simplify-error": "^1.0.1",
     "socket.io-client": "^4.6.2",
     "subscription-listener": "^1.1.2",
@@ -46,5 +43,8 @@
   "peerDependencies": {
     "react": "*",
     "react-native": "*"
+  },
+  "devDependencies": {
+    "@types/react-native-sqlite-storage": "^6.0.5"
   }
 }

package/src/helpers/engine_api.js

@@ -1,12 +1,7 @@
 import { encodeBinary } from './peripherals';
 
-const EngineApiBase = (baseApi, ugly, path) => {
-    const url = new URL(baseApi);
-    if (ugly) {
-        url.pathname = `/e2e/${encodeBinary(path)}`;
-    } else url.pathname = path;
-    return url.href;
-};
+const EngineApiBase = (baseApi, ugly, path) =>
+    ugly ? `${baseApi}/e2e/${encodeBinary(path)}` : `${baseApi}/${path}`;
 
 const apis = {
     _readDocument: (baseApi, ugly) => EngineApiBase(baseApi, ugly, '_readDocument'),

package/src/helpers/peripherals.js

@@ -1,12 +1,10 @@
 import { Buffer } from "buffer";
 import { ServerReachableListener } from "./listeners";
-import aes_pkg from 'crypto-js/aes.js';
-import Utf8Encoder from 'crypto-js/enc-utf8.js';
 import naclPkg from 'tweetnacl';
-import getLodash from "lodash.get";
+import getLodash from "lodash/get";
 import { deserialize, serialize } from "entity-serializer";
+import { CONSTANTS, JSHash } from 'react-native-hash';
 
-const { encrypt, decrypt } = aes_pkg;
 const { box, randomBytes } = naclPkg;
 
 export const listenReachableServer = (callback, projectUrl) => {
@@ -42,7 +40,7 @@ export const normalizeRoute = (route = '') => route.split('').map((v, i, a) =>
 ).join('');
 
 export const shuffleArray = (n) => {
-    const array = [...n];
+    const array = n.slice(0);
     let currentIndex = array.length, randomIndex;
 
     while (currentIndex != 0) {
@@ -66,24 +64,10 @@ export function sortArrayByObjectKey(arr = [], key) {
     });
 };
 
-export async function niceHash(str) {
-    try {
-        // Convert the string to a Uint8Array
-        const encoder = new TextEncoder();
-        const data = encoder.encode(str);
-
-        // Use the Web Crypto API to compute the hash
-        const hashBuffer = await crypto.subtle.digest('SHA-256', data);
-
-        // Convert the ArrayBuffer to a hex string for readability
-        const hashArray = Array.from(new Uint8Array(hashBuffer));
-        const hashHex = hashArray.map(byte => byte.toString(16).padStart(2, '0')).join('');
-
-        // Convert to base64
-        return Buffer.from(hashHex, 'hex').toString('base64');
-    } catch (_) {
-        return str;
-    }
+export async function niceHash(str = '') {
+    const hash = await JSHash(str, CONSTANTS.HashAlgorithms.md5);
+    if (hash.length > str.length) return encodeBinary(str);
+    return hash;
 };
 
 export const sameInstance = (var1, var2) => {
@@ -95,14 +79,6 @@ export const sameInstance = (var1, var2) => {
     }
 };
 
-export const encryptString = (txt, password, iv) => {
-    return encrypt(txt, `${password || ''}${iv || ''}`).toString();
-};
-
-export const decryptString = (txt, password, iv) => {
-    return decrypt(txt, `${password || ''}${iv || ''}`).toString(Utf8Encoder);
-};
-
 export const serializeE2E = async (data, auth_token, serverPublicKey) => {
     const pair = box.keyPair(),
         nonce = randomBytes(box.nonceLength);

package/src/helpers/purger.js

@@ -0,0 +1,264 @@
+import { openDB, SQLITE_COMMANDS, SQLITE_PATH } from "./sqlite_manager";
+import { Validator } from "guard-object";
+import { incrementDatabaseSizeCore } from "../products/database/counter";
+import { incrementFetcherSizeCore } from "../products/http_callable/counter";
+import unsetLodash from 'lodash/unset';
+
+const { LIMITER_DATA, LIMITER_RESULT, DB_COUNT_QUERY, FETCH_RESOURCES } = SQLITE_PATH;
+
+export const purgeRedundantRecords = async (data, builder) => {
+    const { io, maxLocalDatabaseSize = 10485760, maxLocalFetchHttpSize = 10485760 } = builder;
+
+    /**
+     * @type {import('./variables')['CacheStore']['DatabaseStats']}
+     */
+    const { _db_size, _fetcher_size, counters, database, fetchers } = data.DatabaseStats || {};
+
+    if (io) {
+        const purgeDatabase = () => {
+            if (!Validator.POSITIVE_NUMBER(_db_size) || !maxLocalDatabaseSize || _db_size < maxLocalDatabaseSize) return;
+            const DbListing = [];
+
+            breakDbMap(data.DatabaseStore, (projectUrl, dbUrl, dbName, path, value) => {
+                Object.entries(value.instance).forEach(([access_id, obj]) => {
+                    DbListing.push({
+                        builder: { projectUrl, dbUrl, dbName },
+                        path,
+                        access_id,
+                        value: obj
+                    });
+                });
+                Object.entries(value.episode).forEach(([access_id, limitObj]) => {
+                    Object.entries(limitObj).forEach(([limit, obj]) => {
+                        DbListing.push({
+                            builder: { projectUrl, dbUrl, dbName },
+                            path,
+                            access_id,
+                            limit,
+                            value: obj,
+                            isEpisode: true
+                        });
+                    });
+                });
+            });
+
+            breakDbMap(data.DatabaseCountResult, (projectUrl, dbUrl, dbName, path, value) => {
+                Object.entries(value).forEach(([access_id, obj]) => {
+                    DbListing.push({
+                        builder: { projectUrl, dbUrl, dbName },
+                        path,
+                        access_id,
+                        value: obj,
+                        isCount: true
+                    });
+                });
+            });
+
+            const redundantDbRanking = DbListing.sort((a, b) =>
+                a.value.touched - b.value.touched
+            );
+
+            const newSize = maxLocalDatabaseSize / 2;
+            let sizer = _db_size;
+            let cuts = 0;
+
+            for (let i = 0; i < redundantDbRanking.length; i++) {
+                sizer -= redundantDbRanking[i].value.size || 0;
+                ++cuts;
+                if (sizer < newSize) break;
+            }
+
+            console.warn(`purging ${cuts} of ${redundantDbRanking.length} db entities`);
+            redundantDbRanking.slice(0, cuts).forEach(({
+                builder,
+                path,
+                access_id,
+                isCount,
+                isEpisode,
+                limit,
+                value: { size }
+            }) => {
+                const { projectUrl, dbUrl, dbName } = builder;
+                if (isCount) {
+                    unsetLodash(data.DatabaseCountResult, [projectUrl, dbUrl, dbName, path, access_id]);
+                } else {
+                    incrementDatabaseSizeCore(data.DatabaseStats, builder, path, -size);
+                    if (isEpisode) {
+                        unsetLodash(data.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'episode', access_id, limit]);
+                    } else {
+                        unsetLodash(data.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'instance', access_id]);
+                    }
+                }
+            });
+        }
+        const purgeFetcher = () => {
+            if (!Validator.POSITIVE_NUMBER(_fetcher_size) || !maxLocalFetchHttpSize || _fetcher_size < maxLocalFetchHttpSize) return;
+            const redundantFetchRanking = Object.entries(data.FetchedStore).map(([projectUrl, access_id_Obj]) =>
+                Object.entries(access_id_Obj).map(([access_id, data]) => ({
+                    access_id,
+                    projectUrl,
+                    data
+                }))
+            ).flat().sort(([a], [b]) =>
+                a.data.touched - b.data.touched
+            );
+
+            const newSize = maxLocalFetchHttpSize / 2;
+            let sizer = _fetcher_size;
+            let cuts = 0;
+
+            for (let i = 0; i < redundantFetchRanking.length; i++) {
+                sizer -= redundantFetchRanking[i].data.size || 0;
+                ++cuts;
+                if (sizer < newSize) break;
+            }
+
+            console.warn(`purging ${cuts} of ${redundantFetchRanking.length} fetcher entities`);
+            redundantFetchRanking.slice(0, cuts).forEach(({ access_id, data: { size }, projectUrl }) => {
+                incrementFetcherSizeCore(data.DatabaseStats, projectUrl, -size);
+                unsetLodash(data.FetchedStore, [projectUrl, access_id]);
+            });
+            console.log('fetcher purging complete');
+        }
+        purgeDatabase();
+        purgeFetcher();
+    } else {
+        // purge redundant data
+        await Promise.allSettled([
+            (async () => {
+                try {
+                    if (!Validator.POSITIVE_NUMBER(_db_size) || !maxLocalDatabaseSize || _db_size < maxLocalDatabaseSize) return;
+                    const instances = [];
+
+                    [database, counters].forEach((map, i) => {
+                        breakDbMap(map, (projectUrl, dbUrl, dbName, path) => {
+                            instances.push({
+                                builder: { projectUrl, dbUrl, dbName },
+                                isCounter: !!i,
+                                path
+                            });
+                        });
+                    });
+
+                    const redundantDbRanking = await Promise.all(
+                        instances.map(async obj => {
+                            const { builder, isCounter, path } = obj;
+
+                            const sqlite = await openDB(builder);
+
+                            try {
+                                if (isCounter) {
+                                    const data = await sqlite.executeSql(`SELECT * FROM ${DB_COUNT_QUERY(path)}`).then(r =>
+                                        r[0].rows.raw()
+                                    );
+                                    return data.map(v => [v, obj]);
+                                }
+
+                                const [instanceData, resultData] = await Promise.all([
+                                    sqlite.executeSql(`SELECT access_id, touched, size FROM ${LIMITER_DATA(path)}`),
+                                    sqlite.executeSql(`SELECT access_id-limit, touched, size FROM ${LIMITER_RESULT(path)}`)
+                                ]).then(r =>
+                                    r.map(v => v[0].rows.raw())
+                                );
+                                return [...instanceData, ...resultData].map(v => [v, obj]);
+                            } catch (error) {
+                                console.error('redundantDbRanking err:', error);
+                                return [];
+                            } finally {
+                                sqlite.close();
+                            }
+                        })
+                    ).then(r =>
+                        r.flat().sort(([a], [b]) =>
+                            a.touched - b.touched
+                        )
+                    );
+                    const newSize = maxLocalDatabaseSize / 2;
+                    let sizer = _db_size;
+                    let cuts = 0;
+
+                    for (let i = 0; i < redundantDbRanking.length; i++) {
+                        sizer -= redundantDbRanking[i][0].size || 0;
+                        ++cuts;
+                        if (sizer < newSize) break;
+                    }
+
+                    console.warn(`purging ${cuts} of ${redundantDbRanking.length} db entities`);
+                    await Promise.all(redundantDbRanking.slice(0, cuts).map(async ([v, { builder, isCounter, path }]) => {
+                        const sqlite = await openDB(builder);
+                        try {
+                            const table = (isCounter ? DB_COUNT_QUERY : 'access_id-limit' in v ? LIMITER_RESULT : LIMITER_DATA)(path);
+                            const id_field = 'access_id-limit' in v ? 'access_id-limit' : 'access_id';
+
+                            await sqlite.executeSql(SQLITE_COMMANDS.DELETE_ROW(table, `${id_field} = ?`), [v[id_field]]);
+                            if (!isCounter) incrementDatabaseSizeCore(data.DatabaseStats, builder, path, -v.size);
+                        } catch (error) {
+                            console.log('db redundantClearing err:', error);
+                        }
+                        sqlite.close();
+                    }));
+                    console.log('database purging complete');
+                } catch (error) {
+                    console.error('database purging err:', error);
+                }
+            })(),
+            (async () => {
+                try {
+                    if (!Validator.POSITIVE_NUMBER(_fetcher_size) || !maxLocalFetchHttpSize || _fetcher_size < maxLocalFetchHttpSize) return;
+
+                    const redundantFetchRanking = await Promise.all(Object.entries(fetchers).map(async ([projectUrl]) => {
+                        const sqlite = await openDB(FETCH_RESOURCES(projectUrl));
+                        const data = await sqlite.executeSql('SELECT access_id, touched, size FROM main').then(r =>
+                            r[0].rows.raw()
+                        );
+                        return data.map(v => [v, projectUrl]);
+                    })).then(r =>
+                        r.flat().sort(([a], [b]) =>
+                            a.touched - b.touched
+                        )
+                    );
+
+                    const newSize = maxLocalFetchHttpSize / 2;
+                    let sizer = _fetcher_size;
+                    let cuts = 0;
+
+                    for (let i = 0; i < redundantFetchRanking.length; i++) {
+                        sizer -= redundantFetchRanking[i][0].size || 0;
+                        ++cuts;
+                        if (sizer < newSize) break;
+                    }
+
+                    console.warn(`purging ${cuts} of ${redundantFetchRanking.length} fetcher entities`);
+                    await Promise.all(redundantFetchRanking.slice(0, cuts).map(async ([v, projectUrl]) => {
+                        const sqlite = await openDB(FETCH_RESOURCES(projectUrl));
+                        try {
+                            await sqlite.executeSql(SQLITE_COMMANDS.DELETE_ROW('main', 'access_id = ?'), [v.access_id]);
+                            incrementFetcherSizeCore(data.DatabaseStats, projectUrl, -v.size);
+                        } catch (error) {
+                            console.log('fetcher redundantClearing err:', error);
+                        }
+                        sqlite.close();
+                    }));
+                    console.log('fetcher purging complete');
+                } catch (error) {
+                    console.error('fetcher purging err:', error);
+                }
+            })()
+        ]);
+    }
+}
+
+const breakDbMap = (obj, callback) =>
+    Object.entries(obj).forEach(([projectUrl, dbUrlObj]) => {
+        Object.entries(dbUrlObj).forEach(([dbUrl, dbNameObj]) => {
+            Object.entries(dbNameObj).forEach(([dbName, pathObj]) => {
+                Object.entries(pathObj).forEach(([path, value]) => {
+                    callback(projectUrl, dbUrl, dbName, path, value);
+                });
+            });
+        });
+    });
+
+export const purgeInstance = (projectUrl) => {
+    // TODO: purge when signed-out
+}

package/src/helpers/sqlite_manager.js

@@ -0,0 +1,138 @@
+import { enablePromise, openDatabase } from 'react-native-sqlite-storage';
+import { Scoped, SqliteCollective } from './variables';
+import { niceHash } from './peripherals';
+
+enablePromise(true);
+
+/**
+ * this method implement a centralize approach for opening and closing of sqlite database to ensure consistency across multiple task opening and closing the database in diferent order
+ * 
+ * @param {string} name 
+ * @returns {Promise<import('react-native-sqlite-storage').SQLiteDatabase>}
+ */
+export const openDB = async (name) => {
+
+    if (name?.projectUrl) {
+        const { projectUrl, dbUrl, dbName } = name;
+        name = encodeURIComponent(`${projectUrl}_${dbUrl}_${dbName}`) + '.db';
+    }
+
+    const { sqliteKey } = Scoped.ReleaseCacheData;
+
+    if (sqliteKey) name = `${niceHash(sqliteKey)}__${name}`;
+
+    if (!SqliteCollective.openedDb[name]) {
+        SqliteCollective.openedDbProcess[name] = 0;
+        SqliteCollective.openedDb[name] = (SqliteCollective.closeDbPromises[name] || Promise.resolve()).finally(() =>
+            openDatabase({
+                location: 'default',
+                name,
+                key: sqliteKey
+            }).then(db => {
+                const prevClose = db.close.bind(db);
+
+                db.close = () => new Promise((resolve, reject) => {
+                    if (--SqliteCollective.openedDbProcess[name] === 0) {
+                        let willClose;
+                        const timer = setTimeout(async () => {
+                            willClose = true;
+                            delete SqliteCollective.openedDb[name];
+                            delete SqliteCollective.openedDbProcess[name];
+                            SqliteCollective.closeDbPromises[name] = prevClose().then(() => {
+                                resolve('active');
+                            }).catch(e => {
+                                reject(new Error(`${e}`));
+                            }).finally(() => {
+                                delete SqliteCollective.closeDbPromises[name];
+                            });
+                            delete SqliteCollective.openedDbReducerTimer[name];
+                        }, 7);
+
+                        SqliteCollective.openedDbReducerTimer[name] = () => {
+                            clearTimeout(timer);
+                            if (!willClose) resolve('passive');
+                            delete SqliteCollective.openedDbReducerTimer[name];
+                        }
+                    } else resolve('passive');
+                });
+                return db;
+            })
+        );
+    }
+
+    SqliteCollective.openedDbReducerTimer[name]?.();
+    ++SqliteCollective.openedDbProcess[name];
+    const thisDb = await SqliteCollective.openedDb[name];
+    let hasClosed;
+
+    const thisClose = async () => {
+        if (hasClosed) return;
+        hasClosed = true;
+        return (await thisDb.close());
+    }
+
+    return new Proxy({}, {
+        get: (_, n) => {
+            if (n === 'close') {
+                return thisClose;
+            } else if (typeof thisDb[n] === 'function')
+                return thisDb[n].bind(thisDb);
+            return thisDb[n];
+        },
+        set: (_, n, v) => {
+            thisDb[n] = v;
+        }
+    });
+};
+
+/**
+ * this method linearize read/write on sqlite ensuring consistency across concurrent operations
+ * 
+ * @param {any} builder 
+ * @param {string} access_id 
+ * @param {'database' | 'dbQueryCount' | 'httpFetch'} node
+ * @returns {(task: (sqlite: import("react-native-sqlite-storage").SQLiteDatabase) => Promise<{any}> )=> Promise<{any}>}
+ */
+export const useSqliteLinearAccessId = (builder, access_id, node) => async (task) => {
+    const { projectUrl, dbUrl, dbName } = builder;
+    const nodeId = typeof builder === 'string' ? `${builder}_${access_id}` : `${projectUrl}_${dbUrl}_${dbName}_${access_id}`;
+
+    const sqlite = await openDB(builder);
+
+    const thatProcess = Scoped.linearSqliteProcess[node][nodeId];
+
+    const thisPromise = new Promise(async (resolve, reject) => {
+        try {
+            if (thatProcess !== undefined) await thatProcess;
+        } catch (_) { }
+        try {
+            resolve(await task(sqlite));
+        } catch (error) {
+            console.error('useSqliteLinearAccessId err:', error);
+            reject(error);
+        } finally {
+            if (Scoped.linearSqliteProcess[node][nodeId] === thisPromise)
+                delete Scoped.linearSqliteProcess[node][nodeId];
+            sqlite.close();
+        }
+    });
+
+    Scoped.linearSqliteProcess[node][nodeId] = thisPromise;
+    return (await thisPromise);
+};
+
+export const SQLITE_PATH = {
+    FILE_NAME: 'MOSQUITO_TRANSPORT.db',
+    TABLE_NAME: 'MT_MAIN',
+    LIMITER_RESULT: path => `"${encodeURIComponent(path)}-LIMITER_RESULT"`,
+    LIMITER_DATA: path => `"${encodeURIComponent(path)}-LIMITER_DATA"`,
+    DB_COUNT_QUERY: path => `"${encodeURIComponent(path)}-DB_COUNT_QUERY"`,
+    FETCH_RESOURCES: projectUrl => `FETCH_RESOURCES-${encodeURIComponent(projectUrl)}.db`
+};
+
+export const SQLITE_COMMANDS = {
+    MERGE: (table, columns = []) => `INSERT INTO ${table} (${columns.join(', ')}) VALUES (${columns.map(() => '?').join(', ')}) ON CONFLICT(${columns[0]}) DO UPDATE SET ${columns.slice(1).map(v => `${v} = excluded.${v}`).join(', ')}`,
+    UPDATE_COLUMNS: (table, columns = [], query = '') => `UPDATE ${table} SET ${columns.map(v => `${v} = ?`).join(', ')} WHERE ${query}`,
+    CREATE_INDEX: (table, columns) => `CREATE INDEX idx_${columns.join('_')} ON ${table}(${columns.join(', ')})`,
+    DELETE_ROW: (table, query) => `DELETE FROM ${table} WHERE ${query}`
+}