@typed-query-builder/pgsql NPM

@typed-query-builder/pgsql

See typed-query-builder README for more details.
See tests for more query examples.
See generator for a table generator example.

Examples

Generate tables given a connection

import { generate } from '@typed-query-builder/pgsql/generator';

const gen = await generate(conn);
const genFile =  gen.map(t => t.tableDefinition).join('\n\n');

// genFile is now a series of `export const Table = table({ ... })` commands based on your tables.
// generate can be passed options to control variable name, table alias, column aliases, etc.

Query Examples

import mssql from 'mssql';
import { from, update, insert, table } from '@typed-query-builder/builder';
import { exec, prepare, stream } from '@typed-query-builder/pgsql';
import { generate } from '@typed-query-builder/pgsql/generator';

// Define tables
const PersonTable = table({
  name: 'person',
  primary: ['id'],
  fields: {
    id: "INT",
    name: ["VARCHAR", 128],
    email: ["VARCHAR", 128],
    location: ["NULL", "POINT"],
  },
});

const TaskTable = table({
  name: 'task',
  primary: ['id'],
  fields: {
    id: "INT",
    group_id: "INT",
    name: ["NVARCHAR", 128],
    details: "NTEXT",
    done: "BIT",
    done_at: ["NULL", "TIMESTAMP"],
    parent_id: ["NULL", "INT"],
    assigned_to: ["NULL", "INT"],
    assigned_at: ["NULL", "TIMESTAMP"],
    created_at: "TIMESTAMP",
    created_by: ["NULL", "INT"],
  },
});

// Reusable functions to process builders. Can pass transaction or connection or nothing to use global connection.
const getResult = exec(conn);
const getCount = exec(conn, { affectedCount: true });
const getPrepared = prepare(conn);
const getStream = stream(conn);


// Select first record in a table
const first = await from(TaskTable)
  .select('*')
  .first()
  .run( getResult )
;

// Update Done to true
const { affected } = await update(TaskTable)
  .set('done', true)
  .where(({ task }) => task.id.eq(first.id))
  .run( getCount )
;

// Select record in table by parameter ID
const paramedResult = await from(TaskTable)
  .select('*')
  .where(({ task }, { param }) => task.id.eq(param('id')))
  .first()
  .run( exec(conn, { params: { id: first.id } }))
;

// Do it with a prepared statement
const findById = await from(TaskTable)
  .select('*')
  .where(({ task }, { param }) => task.id.eq(param('id')))
  .first()
  .run( getPrepared )
;

try {
  const first = await findById.exec({ id: 23 });
} finally {
  // Prepared statements NEED to be released in a finally
  findById.release();
}

// Inserts with values
const insertIds = await insert(PersonTable, ['name', 'email'])
  .returning(({ person }) => [person.ID])
  .values([
    { name: 'Person 1', email: 'Person1@gmail.com' },
    { name: 'Person 2', email: 'Person2@gmail.com' }
  ])
  .run( getResult )
;

// Inserts with prepared
const insertPrepared = await insert(TaskTable, ['group_id', 'name', 'details'])
  .returning(({ task }) => [task.id, task.created_at])
  .valuesFromParams()
  .run( getPrepared )
;

try
{
  // inserted = [{ ID: number, CreatedAt: Date }]
  const inserted = await insertPrepared.exec({
    group_id: 1223,
    name: 'Task 1b',
    details: 'Task 1b Details',
  });
}
finally
{
  await insertPrepared.release();
}

// Stream large dataset
const streamer = from(TaskTable)
  .select('*')
  .run( getStream )
;

await streamer((task) => {
  // do something with task, potentially async
});