Improving duplicate columns handling by ColumnSet (#978)

* declarations added

* extend implemented

* TS update

* fully implemented

* adding assertions

* update the package

* remove nyc output

* adding tests

* remove coverage

Author: vitaly-t

.github/workflows/ci.yml

@@ -77,8 +77,6 @@ jobs:
         run: npm install
       - name: Initialize Database
         run: npm run test:init
-      - name: Test and Coverage
-        run: npm run coverage
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true

.gitignore

@@ -1,6 +1,7 @@
 .idea/
 node_modules/
 coverage/
+.nyc_output/
 API/
 typescript/*.js
 typescript/*.map

lib/helpers/column-set.js

@@ -56,6 +56,12 @@ const npm = {
  *
  * By default, only the object's own properties are enumerated for column names.
  *
+ * @param {'error' | 'skip' | 'replace'} [options.duplicate = 'error']
+ * Strategy for processing duplicate columns:
+ * - `'error'` - throws {@link external:Error Error} = `Duplicate column name "name".` (Default)
+ * - `'skip'` - skips repeated columns (only the first will be used)
+ * - `'replace'` - replaces repeated columns (the last one will be used)
+ *
  * @returns {helpers.ColumnSet}
  *
  * @see
@@ -166,17 +172,17 @@ const npm = {
  */
 class ColumnSet extends InnerState {
 
-    constructor(columns, opt) {
+    constructor(columns, options) {
         super();
 
         if (!columns || typeof columns !== 'object') {
             throw new TypeError('Invalid parameter \'columns\' specified.');
         }
 
-        opt = assert(opt, ['table', 'inherit']);
+        options = assert(options, ['table', 'inherit', 'duplicate']);
 
-        if (!npm.utils.isNull(opt.table)) {
-            this.table = (opt.table instanceof TableName) ? opt.table : new TableName(opt.table);
+        if (!npm.utils.isNull(options.table)) {
+            this.table = (options.table instanceof TableName) ? options.table : new TableName(options.table);
         }
 
         /**
@@ -190,6 +196,7 @@ class ColumnSet extends InnerState {
          * - **secondary:** to be automatically written into the console (for logging purposes).
          */
 
+        this.columns = [];
 
         /**
          * @name helpers.ColumnSet#columns
@@ -199,22 +206,28 @@ class ColumnSet extends InnerState {
          * Array of {@link helpers.Column Column} objects.
          */
         if (Array.isArray(columns)) {
-            const colNames = {};
-            this.columns = columns.map(c => {
+            const duplicate = options.duplicate || 'error';
+            columns.forEach(c => {
                 const col = (c instanceof Column) ? c : new Column(c);
-                if (col.name in colNames) {
-                    throw new Error(`Duplicate column name "${col.name}".`);
+                const idx = this.columns.findIndex(a => a.name === col.name);
+                if (idx === -1) {
+                    this.columns.push(col);
+                } else {
+                    if (duplicate === 'replace') {
+                        this.columns[idx] = col;
+                        return;
+                    }
+                    if (duplicate !== 'skip') {
+                        throw new Error(`Duplicate column name "${col.name}".`);
+                    }
                 }
-                colNames[col.name] = true;
-                return col;
             });
         } else {
             if (columns instanceof Column) {
                 this.columns = [columns];
             } else {
-                this.columns = [];
                 for (const name in columns) {
-                    if (opt.inherit || Object.prototype.hasOwnProperty.call(columns, name)) {
+                    if (options.inherit || Object.prototype.hasOwnProperty.call(columns, name)) {
                         this.columns.push(new Column(name));
                     }
                 }
@@ -415,13 +428,18 @@ ColumnSet.prototype.assignColumns = function (options) {
  * @description
  * Creates a new {@link helpers.ColumnSet ColumnSet}, by joining the two sets of columns.
  *
- * If the two sets contain a column with the same `name` (case-sensitive), an error is thrown.
+ * If the two sets contain a column with the same `name` (case-sensitive), an error is thrown (unless `opts.skip` is set to `true`).
  *
  * @param {helpers.Column|helpers.ColumnSet|array} columns
  * Columns to be appended, of the same type as parameter `columns` during {@link helpers.ColumnSet ColumnSet} construction, except:
  * - it can also be of type {@link helpers.ColumnSet ColumnSet}
  * - it cannot be a simple object (properties enumeration is not supported here)
  *
+ * @param {object} [options]
+ *
+ * @param {boolean} [options.skip = false]
+ * When set to `true`, it skips duplicate columns (by default, it throws an error).
+ *
  * @returns {helpers.ColumnSet}
  * New {@link helpers.ColumnSet ColumnSet} object with the extended/concatenated list of columns.
  *
@@ -465,13 +483,12 @@ ColumnSet.prototype.assignColumns = function (options) {
  * //    ]
  * // }
  */
-ColumnSet.prototype.extend = function (columns) {
-    let cs = columns;
-    if (!(cs instanceof ColumnSet)) {
-        cs = new ColumnSet(columns);
-    }
-    // Any duplicate column will throw Error = 'Duplicate column name "name".',
-    return new ColumnSet(this.columns.concat(cs.columns), {table: this.table});
+ColumnSet.prototype.extend = function (columns, options) {
+    options = assert(options, ['skip']);
+    const duplicate = options.skip ? 'skip' : 'error';
+    const cs = columns instanceof ColumnSet ? columns : new ColumnSet(columns, {duplicate});
+    const joinedCols = this.columns.concat(...cs.columns);
+    return new ColumnSet(joinedCols, {table: this.table, duplicate});
 };
 
 /**
@@ -536,23 +553,10 @@ ColumnSet.prototype.extend = function (columns) {
  *
  */
 ColumnSet.prototype.merge = function (columns) {
-    let cs = columns;
-    if (!(cs instanceof ColumnSet)) {
-        cs = new ColumnSet(columns);
-    }
-    const colNames = {}, cols = [];
-    this.columns.forEach((c, idx) => {
-        cols.push(c);
-        colNames[c.name] = idx;
-    });
-    cs.columns.forEach(c => {
-        if (c.name in colNames) {
-            cols[colNames[c.name]] = c;
-        } else {
-            cols.push(c);
-        }
-    });
-    return new ColumnSet(cols, {table: this.table});
+    const duplicate = 'replace';
+    const cs = columns instanceof ColumnSet ? columns : new ColumnSet(columns, {duplicate});
+    const joinedCols = this.columns.concat(...cs.columns);
+    return new ColumnSet(joinedCols, {table: this.table, duplicate});
 };
 
 /**

lib/helpers/column.js

@@ -364,7 +364,7 @@ npm.utils.addInspection(Column, function () {
  * Used by methods {@link helpers.update update} and {@link helpers.sets sets}, ignored by methods {@link helpers.insert insert} and
  * {@link helpers.values values}. It indicates that the column is reserved for a `WHERE` condition, not to be set or updated.
  *
- * It can be set from a string initialization, by adding `?` in front of the name.
+ * It can be set from a string initialization by adding `?` in front of the name.
  *
  * @property {*} [def]
  * Default value for the property, to be used only when the source object doesn't have the property.
@@ -379,7 +379,7 @@ npm.utils.addInspection(Column, function () {
  * Used by methods {@link helpers.update update} (for a single object) and {@link helpers.sets sets}, ignored by methods
  * {@link helpers.insert insert} and {@link helpers.values values}.
  *
- * It is also ignored when conditional flag `cnd` is set.
+ * It is also ignored when the conditional flag `cnd` is set.
  *
  */
 

lib/main.js

@@ -34,7 +34,7 @@ let originalClientConnect;
  * @module pg-promise
  *
  * @description
- * ## pg-promise v12.0
+ * ## pg-promise v12.5
  * All documentation here is for the latest official release only.
  *
  * ### Initialization Options

package.json

@@ -1,12 +1,12 @@
 {
   "name": "pg-promise",
-  "version": "12.4.0",
+  "version": "12.5.0",
   "description": "PostgreSQL interface for Node.js",
   "main": "lib/index.js",
   "typings": "typescript/pg-promise.d.ts",
   "scripts": {
     "spelling": "cspell --config=.cspell.json \"**/*.{md,ts,js}\" --no-progress",
-    "coverage": "istanbul cover ./node_modules/jasmine-node/bin/jasmine-node --captureExceptions test",
+    "coverage": "nyc --reporter=html --reporter=text ./node_modules/jasmine-node/bin/jasmine-node --captureExceptions test",
     "doc": "jsdoc -c ./jsdoc/jsdoc.js ./jsdoc/README.md -t ./jsdoc/templates/custom",
     "lint": "eslint ./lib ./test/*.js ./test/db",
     "lint:fix": "npm run lint -- --fix",
@@ -42,12 +42,12 @@
   },
   "dependencies": {
     "assert-options": "0.8.3",
-    "pg": "8.17.2",
+    "pg": "8.18.0",
     "pg-minify": "1.8.0",
     "spex": "4.1.0"
   },
   "peerDependencies": {
-    "pg-query-stream": "4.11.2"
+    "pg-query-stream": "4.12.0"
   },
   "devDependencies": {
     "@eslint/js": "9.39.2",
@@ -56,10 +56,10 @@
     "cspell": "9.6.2",
     "eslint": "9.39.2",
     "globals": "17.2.0",
-    "istanbul": "0.4.5",
     "jasmine-node": "3.0.0",
     "jsdoc": "4.0.5",
     "JSONStream": "1.3.5",
+    "nyc": "17.1.0",
     "typescript": "5.9.3"
   }
 }

test/help.spec.js

@@ -517,6 +517,10 @@ describe('ColumnSet', () => {
             expect(cs.columns[0].name).toBe('val');
             expect(cs.columns[1].name).toBe('msg');
         });
+        it('must not ignore same columns when "skip" is set', () => {
+            const cs = new helpers.ColumnSet(['one', 'one'], {duplicate: 'skip'});
+            expect(cs.columns.length).toBe(1);
+        });
     });
 
     describe('property \'names\'', () => {
@@ -677,6 +681,10 @@ describe('ColumnSet', () => {
                 cs.extend(['two']);
             }).toThrow('Duplicate column name "two".');
         });
+        it('must ignore duplicates when "skip" is set', () => {
+            const cs = new helpers.ColumnSet(['one', 'two']);
+            expect(cs.extend(['one', 'two'], {skip: true}).columns.length).toBe(2);
+        });
     });
 
     describe('method \'merge\'', () => {
@@ -708,7 +716,6 @@ describe('ColumnSet', () => {
                 new helpers.ColumnSet(['one', 'one']);
             }).toThrow('Duplicate column name "one".');
         });
-
         it('must throw on invalid options', () => {
             expect(() => {
                 new helpers.ColumnSet({}, 123);

typescript/pg-promise.d.ts

@@ -130,6 +130,7 @@ declare namespace pgPromise {
     interface IColumnSetOptions {
         table?: string | ITable | TableName
         inherit?: boolean
+        duplicate?: 'error' | 'skip' | 'replace'
     }
 
     interface ITable {
@@ -206,8 +207,12 @@ declare namespace pgPromise {
             skip?: string | string[] | ((c: Column<T>) => boolean)
         }): string
 
-        extend<K extends string>(columns: K[]): ColumnSet<T & Record<K, unknown>>
-        extend<S>(columns: Column<S> | ColumnSet<S> | Array<IColumnConfig<S> | Column<S>>): ColumnSet<T & S>
+        extend<K extends string>(columns: K[], opts?: {
+            skip?: boolean
+        }): ColumnSet<T & Record<K, unknown>>
+        extend<S>(columns: Column<S> | ColumnSet<S> | Array<IColumnConfig<S> | Column<S>>, opts?: {
+            skip?: boolean
+        }): ColumnSet<T & S>
 
         merge<K extends string>(columns: K[]): ColumnSet<T & Record<K, unknown>>
         merge<S>(columns: Column<S> | ColumnSet<S> | Array<IColumnConfig<S> | Column<S>>): ColumnSet<T & S>