utilitas 1995.2.11 → 1995.2.13

package/lib/dbio.mjs

@@ -1,5 +1,5 @@
 import {
-    assertSet, ensureArray, ensureString, log as _log, need,
+    assertSet, ensureArray, ensureString, log as _log, need, throwError,
 } from './utilitas.mjs';
 
 import { isPrimary } from './callosum.mjs';
@@ -7,21 +7,27 @@ import { isPrimary } from './callosum.mjs';
 const _NEED = ['mysql2', 'pg'];
 const [mysqlDefaultPort, postgresqlDefaultPort] = [3306, 5432];
 const [mysqlQuote, postgresqlQuote] = ['`', ''];
+const IFSC = 'information_schema';
 const orders = { '+': 'ASC', '-': 'DESC' };
+const [INSERT, UPDATE, RETURNING] = ['INSERT', 'UPDATE', 'RETURNING'];
+const RETURNING_ALL = ` RETURNING *`;
 const [fieldId, fieldAny] = ['id', '*'];
 const fieldCount = `COUNT(${fieldAny})`;
+const direct = { direct: true };
 const comparison = ['=', '>', '<', '<>', '!='];
 const fieldNoQuote = [fieldAny, fieldCount];
-const log = (content) => _log(content, import.meta.url);
-const defaultKey = (options) => options && options.key ? options.key : fieldId;
+const log = content => _log(content, import.meta.url);
+const defaultKey = options => options && options.key ? options.key : fieldId;
 const queryOne = async (...args) => (await query(...args))[0];
 const assertForce = op => assert(op?.force, "Option 'force' is required.", 500);
 const [MYSQL, POSTGRESQL] = ['MYSQL', 'POSTGRESQL'];
 const quote = name => `${bracket}${name}${bracket}`;
 const join = elements => elements.join(', ');
+const assembleDelete = table => `DELETE FROM ${quote(assertTable(table))}`;
+const execByQuery = async (...a) => await rawQuery(...distillArguments(...a));
 
-let provider, pool, actExecute, bracket, actDuplicate, sqlShowTable,
-    defaultPlaceholder, sqlShowIndex, fieldCountResult;
+let provider, pool, actExecute, bracket, sqlShowTables, placeholder,
+    sqlShowIndexes, fieldCountResult, sqlDesc, doublePlaceholder;
 
 const init = async (options) => {
     if (options) {
@@ -34,14 +40,17 @@ const init = async (options) => {
                 const mysql = await need('mysql2/promise');
                 delete options.provider;
                 [
-                    provider, pool, port, actExecute, bracket, actDuplicate,
-                    sqlShowTable, defaultPlaceholder, sqlShowIndex,
-                    fieldCountResult,
+                    provider, pool, port, actExecute, bracket, sqlShowTables,
+                    placeholder, fieldCountResult,
                 ] = [
                         MYSQL, mysql.createPool(options), mysqlDefaultPort,
-                        'execute', mysqlQuote, 'ON DUPLICATE KEY', 'SHOW TABLES',
-                        '?', 'SHOW INDEXES FROM ??', fieldCount,
+                        'execute', mysqlQuote, 'SHOW TABLES', '?', fieldCount,
                     ];
+                doublePlaceholder = `${placeholder}${placeholder}`;
+                [sqlShowIndexes, sqlDesc] = [
+                    `SHOW INDEXES FROM ${doublePlaceholder}`,
+                    `DESC ${doublePlaceholder}`,
+                ];
                 break;
             case 'PG':
             case 'POSTGRE':
@@ -50,16 +59,17 @@ const init = async (options) => {
                 // https://node-postgres.com/apis/pool
                 const { Pool } = await need('pg');
                 [
-                    provider, pool, port, actExecute, bracket, actDuplicate,
-                    sqlShowTable, defaultPlaceholder, sqlShowIndex,
+                    provider, pool, port, actExecute, bracket, placeholder,
                     fieldCountResult,
                 ] = [
                         POSTGRESQL, new Pool(options), postgresqlDefaultPort,
-                        'query', postgresqlQuote, 'ON CONFLICT DO',
-                        "SELECT * FROM information_schema.tables WHERE table_schema = 'public'",
-                        '$1', 'SELECT * FROM pg_indexes WHERE tablename = $1',
-                        'count',
+                        'query', postgresqlQuote, '$1', 'count',
                     ];
+                [sqlShowTables, sqlShowIndexes, sqlDesc] = [
+                    [`${IFSC}.tables`, 'table_schema', "'public'", direct],
+                    ['pg_indexes', 'tablename', ''],
+                    [`${IFSC}.COLUMNS`, 'TABLE_NAME', ''],
+                ].map(args => assembleQueryByKeyValue(...args));
                 break;
             default:
                 assert(
@@ -134,25 +144,29 @@ const execute = async (...args) => {
     }
 };
 
-const assertTable = (table, message, status) =>
+const assertTable = (table, message, status) => {
     assert(table, message || 'Table is required.', status || 500);
+    return table;
+};
 
 const assertKeyValue = (key, value) => {
     assert(key, 'Key is required.', 500);
     assertSet(value, 'Value is required.', 500);
 };
 
+const assembleQueryByKeyValue = (table, key, value, options) =>
+    assembleQuery(table) + assembleKeyValue(key, value, options);
+
 // const assertTableKeyValue = (table, key, value) => {
 //     assertTable(table);
 //     assertKeyValue(key, value);
 // };
 
 const assembleQuery = (table, options) => {
-    options = options || {};
     assertTable(table);
     const fields = [];
-    ensureArray(options.fields).map((field) => {
-        fields.push(fieldNoQuote.includes(field) || options.noQuote
+    ensureArray(options?.fields).map((field) => {
+        fields.push(fieldNoQuote.includes(field) || options?.noQuote
             ? field : quote(field));
     });
     if (!fields.length) { fields.push(fieldAny); }
@@ -160,73 +174,94 @@ const assembleQuery = (table, options) => {
 };
 
 const rawAssembleKeyValue = (key, value, options) => {
-    options = options || {};
     assertKeyValue(key, value);
-    let express = `${getComparison(value) || '='} ${defaultPlaceholder}`;
+    let _placeholder;
+    switch (provider) {
+        case MYSQL:
+            _placeholder = placeholder;
+            break;
+        case POSTGRESQL:
+            _placeholder = `$${options?.placeholderIndex || 1}`;
+    }
+    const val = options?.direct ? value : _placeholder;
+    let express = `${getComparison(value) || '='} ${val}`;
     if (Array.isArray(value)) {
         assert(value.length, 'Invalid array value.', 500);
-        express = `IN (${defaultPlaceholder})`;
-    } else if (value === null) { express = `IS ${defaultPlaceholder}`; }
-    return `${options.prefix || ''}${quote(key)} ${express}`;
+        express = `IN (${val})`;
+    } else if (value === null) { express = `IS ${val}`; }
+    return `${options?.prefix || ''}${quote(key)} ${express}`;
 };
 
-const assembleKeyValue = (key, value, options) => {
-    options = options || {};
-    options.prefix = ' WHERE ';
-    return rawAssembleKeyValue(key, value, options);
-};
+const assembleKeyValue = (key, value, options) => rawAssembleKeyValue(
+    key, value, { ...options || {}, prefix: ' WHERE ' }
+);
 
 const pushValue = (values, item) => values.push(
     Object.isObject(item) || Array.isArray(item) ? JSON.stringify(item) : item
 );
 
 const assembleSet = (data, options) => {
-    options = options || {};
-    const [isArray, result] = [options.asArray || Array.isArray(data), []];
+    const [isArray, result] = [options?.asArray || Array.isArray(data), []];
     ensureArray(data).map((item) => {
         assert(Object.keys(item).length, 'Fields are required.', 500);
-        let [keys, vals, values, dupSql] = [[], [], [], []];
+        let [pairs, keys, vals, values, dupSql, i, sql]
+            = [[], [], [], [], [], 0, ''];
         for (let k in item) {
             keys.push(k);
             switch (provider) {
-                case MYSQL: vals.push('?'); break;
-                case POSTGRESQL: vals.push(`$${vals.length + 1}`); break;
+                case MYSQL:
+                    vals.push('?');
+                    pairs.push(`${quote(k)} = ?`);
+                    break;
+                case POSTGRESQL:
+                    vals.push(`$${++i}`);
+                    pairs.push(`${quote(k)} = $${i}`);
             }
             pushValue(values, item[k]);
         }
-        if (options.upsert) {
+        if (options?.upsert) {
             for (let k in item) {
-                dupSql.push(`${quote(k)} = ?`);
+                switch (provider) {
+                    case MYSQL: dupSql.push(`${quote(k)} = ?`); break;
+                    case POSTGRESQL: dupSql.push(`${quote(k)} = $${++i}`); break;
+                }
                 pushValue(values, item[k]);
             }
-            dupSql = ` ${actDuplicate} UPDATE ${join(dupSql)}`;
+            switch (provider) {
+                case MYSQL:
+                    dupSql = ` ON DUPLICATE KEY UPDATE ${join(dupSql)}`;
+                    break;
+                case POSTGRESQL:
+                    const target = options?.key ? ` (${options?.key})` : '';
+                    dupSql = ` ON CONFLICT${target} DO UPDATE SET ${join(dupSql)}`;
+                    break;
+            }
         } else { dupSql = ''; }
-        const sql = `${options.prefix || ''}`
-            + `(${join(keys.map(quote))}) VALUES (${join(vals)})${dupSql}`
-            + `${options.subfix || ''}`
+        switch (options?.action) {
+            case INSERT:
+                sql = `(${join(keys.map(quote))}) VALUES (${join(vals)})`;
+                break;
+            case UPDATE:
+                sql = `SET ${pairs.join(', ')}`;
+                break;
+            default:
+                throwError(`Invalid action: '${options?.action}'.`, 400);
+        }
+        sql = `${options?.prefix || ''}${sql}${dupSql}${options?.subfix || ''}`;
         result.push({ sql, values, object: item });
     });
     return isArray ? result : result[0];
 };
 
-const assembleInsert = (table, data, options) => {
-    options = options || {};
-    assertTable(table);
-    options.prefix = `INSERT INTO ${quote(table)} `;
-    return assembleSet(data, options);
-};
-
-const assembleUpdate = (table, data, options) => {
-    options = options || {};
-    assertTable(table);
-    options.prefix = `UPDATE ${quote(table)} `;
-    return assembleSet(data, options);
-};
+const assembleInsert = (table, data, options) => assembleSet(data, {
+    ...options || {}, action: INSERT,
+    prefix: `INSERT INTO ${quote(assertTable(table))} `,
+});
 
-const assembleDelete = (table) => {
-    assertTable(table);
-    return `DELETE FROM ${quote(table)}`;
-};
+const assembleUpdate = (table, data, options) => assembleSet(data, {
+    ...options || {}, action: UPDATE,
+    prefix: `UPDATE ${quote(assertTable(table))} `,
+});
 
 const assembleTail = (options) => {
     let sort = [];
@@ -240,7 +275,7 @@ const assembleTail = (options) => {
 };
 
 const tables = async (options) => {
-    const resp = await query(sqlShowTable);
+    const resp = await query(sqlShowTables);
     return options?.raw ? resp : resp.map(x => {
         switch (provider) {
             case MYSQL: return Object.values(x)[0];
@@ -251,15 +286,18 @@ const tables = async (options) => {
 
 const desc = async (table, options) => {
     assertTable(table);
-    const [resp, result] = [await query('DESC ??', [table]), {}];
+    const [resp, result] = [await query(sqlDesc, [table]), {}];
     if (options?.raw) { return resp; }
-    resp.map(x => result[x.Field] = x);
+    switch (provider) {
+        case MYSQL: resp.map(x => result[x.Field] = x); break;
+        case POSTGRESQL: resp.map(x => result[x.column_name] = x); break;
+    }
     return result;
 };
 
 const indexes = async (table, options) => {
     assertTable(table);
-    const [resp, result] = [await query(sqlShowIndex, [table]), {}];
+    const [resp, result] = [await query(sqlShowIndexes, [table]), {}];
     if (options?.raw) { return resp; }
     switch (provider) {
         case MYSQL: resp.map(x => result[x.Key_name] = x); break;
@@ -271,36 +309,37 @@ const indexes = async (table, options) => {
 const drop = async (table, options) => {
     assertTable(table);
     assertForce(options);
-    return await query('DROP TABLE IF EXISTS ??', [table]);
+    const act = {
+        [MYSQL]: [query, [`DROP TABLE IF EXISTS ${doublePlaceholder}`, [table]]],
+        [POSTGRESQL]: [execute, [`DROP TABLE IF EXISTS ${table}`]],
+    }[provider]
+    return await act[0](...act[1]);
 };
 
 const queryAll = (table, options) =>
     query(`${assembleQuery(table, options)}${assembleTail(options)}`);
 
 const queryByKeyValue = async (table, key, value, options) => {
-    options = options || {};
     const sql = assembleQuery(table, options)
         + assembleKeyValue(key, value)
         + assembleTail(options);
     const resp = await query(sql, [value]);
-    return options.unique ? (resp && resp.length ? resp[0] : null) : resp;
+    return options?.unique ? (resp && resp.length ? resp[0] : null) : resp;
 };
 
-const queryById = async (table, id, options) => {
-    options = options || {};
-    options.unique = !Array.isArray(id);
-    return await queryByKeyValue(table, defaultKey(options), id, options);
-};
+const queryById = async (table, id, options) => await queryByKeyValue(
+    table, defaultKey(options), id,
+    { ...options || {}, unique: !Array.isArray(id) }
+);
 
 const insert = async (table, fields, options) => {
-    options = options || {};
     let [isArray, key, ids, error, result]
         = [Array.isArray(fields), defaultKey(options), [], [], []];
-    const subfix = provider === POSTGRESQL ? (options.skipEcho ? (
-        options.key ? ` RETURNING ${key}` : ''
-    ) : ` RETURNING *`) : '';
+    const subfix = provider === POSTGRESQL ? (options?.skipEcho ? (
+        options?.key ? ` ${RETURNING} ${key}` : ''
+    ) : RETURNING_ALL) : '';
     for (let item of assembleInsert(
-        table, fields, { ...options, asArray: true, subfix })
+        table, fields, { ...options || {}, asArray: true, subfix })
     ) {
         try {
             const resp = await execute(item.sql, item.values);
@@ -314,7 +353,7 @@ const insert = async (table, fields, options) => {
             ids.push(resp.insertId);
         } catch (err) { error.push(err); }
     }
-    if (!options.skipEcho && ids.length) {
+    if (!options?.skipEcho && ids.length) {
         switch (provider) {
             case MYSQL:
                 result = await queryById(table, ids, options);
@@ -345,13 +384,18 @@ const countByKeyValue = async (table, key, value) => {
 };
 
 const updateByKeyValue = async (table, key, value, fields, options) => {
-    options = options || {};
     assertTable(table);
-    let { sql, values } = assembleUpdate(table, fields);
-    sql += assembleKeyValue(key, value) + assembleTail(options);
+    const dfKey = defaultKey(options);
+    const subfix = assembleKeyValue(key, value, {
+        placeholderIndex: Object.keys(fields).length + 1,
+    }) + (provider === POSTGRESQL ? (options?.skipEcho ? (
+        options?.key ? ` ${RETURNING} ${dfKey}` : ''
+    ) : RETURNING_ALL) : '');
+    let { sql, values } = assembleUpdate(table, fields, { subfix });
+    sql += assembleTail(options);
     const resp = await query(sql, [...values, value]);
-    return options.skipEcho
-        ? resp : await queryByKeyValue(table, key, value, options);
+    return !options?.skipEcho && provider === MYSQL
+        ? await queryByKeyValue(table, key, value, options) : resp;
 };
 
 const updateById = async (table, id, fields, options) => {
@@ -365,11 +409,13 @@ const deleteByKeyValue = async (table, key, value, options) => {
     const sql = assembleDelete(table)
         + assembleKeyValue(key, value)
         + assembleTail(options);
-    return await query(sql, [value]);
+    return await {
+        [MYSQL]: query, [POSTGRESQL]: execByQuery,
+    }[provider](sql, [value]);
 };
 
-const deleteById = (table, id, options) =>
-    deleteByKeyValue(table, defaultKey(options), id);
+const deleteById = async (table, id, options) =>
+    await deleteByKeyValue(table, defaultKey(options), id);
 
 const deleteAll = async (table, options) => {
     assertForce(options);

package/lib/manifest.mjs

@@ -1,7 +1,7 @@
 const manifest = {
     "name": "utilitas",
     "description": "Just another common utility for JavaScript.",
-    "version": "1995.2.11",
+    "version": "1995.2.13",
     "private": false,
     "homepage": "https://github.com/Leask/utilitas",
     "main": "index.mjs",

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "utilitas",
     "description": "Just another common utility for JavaScript.",
-    "version": "1995.2.11",
+    "version": "1995.2.13",
     "private": false,
     "homepage": "https://github.com/Leask/utilitas",
     "main": "index.mjs",