How do I properly insert multiple rows into PG with node-postgres?

Use pg-format like below.

var format = require('pg-format');

var values = [
  [7, 'john22', '[email protected]', '9999999922'], 
  [6, 'testvk', '[email protected]', '88888888888']
];
client.query(format('INSERT INTO users (id, name, email, phone) VALUES %L', values),[], (err, result)=>{
  console.log(err);
  console.log(result);
});

One other way using PostgreSQL json functions:

client.query('INSERT INTO table (columns) ' +
  'SELECT m.* FROM json_populate_recordset(null::your_custom_type, $1) AS m',
  [JSON.stringify(your_json_object_array)], function(err, result) {
    if (err) {
      console.log(err);
    } else {
      console.log(result);
    }
});

Using npm module postgres (porsager/postgres) which has Tagged Template Strings at the core:

https://github.com/porsager/postgres#multiple-inserts-in-one-query

const users = [{
  name: 'Murray',
  age: 68,
  garbage: 'ignore'
},
{
  name: 'Walter',
  age: 80,
  garbage: 'ignore'
}]

sql`insert into users ${ sql(users, 'name', 'age') }`

// Is translated to:
insert into users ("name", "age") values ($1, $2), ($3, $4)

// Here you can also omit column names which will use all object keys as columns
sql`insert into users ${ sql(users) }`

// Which results in:
insert into users ("name", "age", "garbage") values ($1, $2, $3), ($4, $5, $6)

Just thought I'd post since it's like brand new out of beta and I've found it to be a better philosophy of SQL library. I think would be preferable over the other postgres/node libraries posted in other answers. IMHO

You are going to have to generate the query dynamically. Although possible, this is risky, and could easily lead to SQL Injection vulnerabilities if you do it wrong. It's also easy to end up with off by one errors between the index of your parameters in the query and the parameters you're passing in.

That being said, here is an example of how you could do write this, assuming you have an array of users that looks like {name: string, email: string}:

client.query(
  `INSERT INTO table_name (name, email) VALUES ${users.map(() => `(?, ?)`).join(',')}`,
  users.reduce((params, u) => params.concat([u.name, u.email]), []),
  callBack,
)

An alternative approach, is to use a library like @databases/pg (which I wrote):

await db.query(sql`
  INSERT INTO table_name (name, email)
  VALUES ${sql.join(users.map(u => sql`(${u.name}, ${u.email})`), ',')}
`)

@databases requires the query to be tagged with sql and uses that to ensure any user data you pass is always automatically escaped. This also lets you write the parameters inline, which I think makes the code much more readable.

Simple usage of pg module's built-in parameterized query with flattened values. Thought it could be what some are looking for. The following is for convenience.

function makeValuesString(columnCount, rowCount) {
  return Array.from({ length: rowCount }, (_, i) => `(${Array.from({ length: columnCount }, (_, j) => `$${i * columnCount + j + 1}`).join(', ')})`).join(', ')
}

const columns = ['id', 'column1', 'column2', 'column3'] // columnNames
const query = {
  text: `INSERT INTO tableName (${columns.join(', ')})
  VALUES ${makeValuesString(columns.length, rows.length)}`,
  values: rows.reduce((acc, cv) => {
    acc.push(...cv) // rowValues
    return acc
  }, [])
}

const result = await client.query(query)

The simplest way to do this these days is unnest:

client.query(
  "insert into tableName (name, email) select * from unnest($1::text[], $2::text[])",
  [['john', 'ron'], ['[email protected]', '[email protected]']]
)

I think, but have not confirmed, that this automatically works with Buffers and maybe bigints, which would require manual conversion with the json_populate_recordset approach. But if you have an array of objects, you have to break it up into separate arrays in your code:

client.query(
  "insert into tableName (name, email) select * from unnest($1::text[], $2::text[])",
  [users.map(u => u.name), users.map(u => u.email)]
)

It also doesn't work if one of your table columns is array-valued. For that you have to use a json_populate_recordset type approach or do this workaround:

// imagine you have a table with `emails text[]` column
client.query(
  `
    insert into tableName (name, emails)
      select name, emails::text[]
      from unnest($1::text[], $2::text[])
  `,
  [users.map(u => u.name), users.map(u => formatPgArray(u.email))]
                           // you would need an implementation for formatPgArray
)

Another option is to use a COPY statement with the pg-copy-streams package.