utilitas 1995.2.12 → 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';
@@ -9,6 +9,8 @@ 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 };
@@ -22,9 +24,10 @@ 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, sqlShowTables,
-    placeholder, sqlShowIndexes, fieldCountResult, sqlDesc, doublePlaceholder;
+let provider, pool, actExecute, bracket, sqlShowTables, placeholder,
+    sqlShowIndexes, fieldCountResult, sqlDesc, doublePlaceholder;
 
 const init = async (options) => {
     if (options) {
@@ -37,12 +40,11 @@ const init = async (options) => {
                 const mysql = await need('mysql2/promise');
                 delete options.provider;
                 [
-                    provider, pool, port, actExecute, bracket, actDuplicate,
-                    sqlShowTables, placeholder, fieldCountResult,
+                    provider, pool, port, actExecute, bracket, sqlShowTables,
+                    placeholder, fieldCountResult,
                 ] = [
                         MYSQL, mysql.createPool(options), mysqlDefaultPort,
-                        'execute', mysqlQuote, 'ON DUPLICATE KEY',
-                        'SHOW TABLES', '?', fieldCount,
+                        'execute', mysqlQuote, 'SHOW TABLES', '?', fieldCount,
                     ];
                 doublePlaceholder = `${placeholder}${placeholder}`;
                 [sqlShowIndexes, sqlDesc] = [
@@ -57,12 +59,11 @@ const init = async (options) => {
                 // https://node-postgres.com/apis/pool
                 const { Pool } = await need('pg');
                 [
-                    provider, pool, port, actExecute, bracket, actDuplicate,
-                    placeholder, fieldCountResult,
+                    provider, pool, port, actExecute, bracket, placeholder,
+                    fieldCountResult,
                 ] = [
                         POSTGRESQL, new Pool(options), postgresqlDefaultPort,
-                        'query', postgresqlQuote, 'ON CONFLICT DO', '$1',
-                        'count',
+                        'query', postgresqlQuote, '$1', 'count',
                     ];
                 [sqlShowTables, sqlShowIndexes, sqlDesc] = [
                     [`${IFSC}.tables`, 'table_schema', "'public'", direct],
@@ -174,7 +175,15 @@ const assembleQuery = (table, options) => {
 
 const rawAssembleKeyValue = (key, value, options) => {
     assertKeyValue(key, value);
-    const val = options?.direct ? value : placeholder;
+    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);
@@ -195,36 +204,63 @@ const assembleSet = (data, options) => {
     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) {
             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) => assembleSet(data, {
-    ...options || {}, prefix: `INSERT INTO ${quote(assertTable(table))} `
+    ...options || {}, action: INSERT,
+    prefix: `INSERT INTO ${quote(assertTable(table))} `,
 });
 
 const assembleUpdate = (table, data, options) => assembleSet(data, {
-    ...options || {}, prefix: `UPDATE ${quote(assertTable(table))} `
+    ...options || {}, action: UPDATE,
+    prefix: `UPDATE ${quote(assertTable(table))} `,
 });
 
 const assembleTail = (options) => {
@@ -300,8 +336,8 @@ const insert = async (table, fields, options) => {
     let [isArray, key, ids, error, result]
         = [Array.isArray(fields), defaultKey(options), [], [], []];
     const subfix = provider === POSTGRESQL ? (options?.skipEcho ? (
-        options?.key ? ` RETURNING ${key}` : ''
-    ) : ` RETURNING *`) : '';
+        options?.key ? ` ${RETURNING} ${key}` : ''
+    ) : RETURNING_ALL) : '';
     for (let item of assembleInsert(
         table, fields, { ...options || {}, asArray: true, subfix })
     ) {
@@ -349,11 +385,17 @@ const countByKeyValue = async (table, key, value) => {
 
 const updateByKeyValue = async (table, key, value, fields, 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) => {
@@ -367,7 +409,9 @@ 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 = async (table, id, options) =>

package/lib/manifest.mjs

@@ -1,7 +1,7 @@
 const manifest = {
     "name": "utilitas",
     "description": "Just another common utility for JavaScript.",
-    "version": "1995.2.12",
+    "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.12",
+    "version": "1995.2.13",
     "private": false,
     "homepage": "https://github.com/Leask/utilitas",
     "main": "index.mjs",