Initial commit

Author: Valentin Vasilyev

.eslintrc

@@ -0,0 +1,12 @@
+module.exports = {
+  "env": {
+    "commonjs": true,
+    "es6": true,
+    "node": true,
+    "jest": true,
+  },
+  "extends": "eslint:recommended",
+  "rules": {
+    // ...
+  },
+};

.gitignore

@@ -0,0 +1,3 @@
+node_modules/
+yarn-error.log
+.idea

.prettierrc

@@ -0,0 +1,12 @@
+{
+  "printWidth": 120,
+  "tabWidth": 2,
+  "useTabs": false,
+  "semi": false,
+  "singleQuote": true,
+  "jsxSingleQuote": true,
+  "trailingComma": "es5",
+  "bracketSpacing": true,
+  "jsxBracketSameLine": false,
+  "arrowParens": "always"
+}

README.md

@@ -0,0 +1,5 @@
+WEERM
+============================
+
+Super tiny ORM for PG + Node
+

jest.config.js

@@ -0,0 +1,3 @@
+module.exports = {
+  testEnvironment: "node",
+};

package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@fingerprintjs/weerm",
+  "version": "1.0.0",
+  "description": "Really tiny ORM for PostgreSQL",
+  "main": "index.js",
+  "repository": "https://github.com/fingerprintjs/weerm",
+  "author": "FingerprintJS",
+  "license": "MIT",
+  "private": false,
+  "dependencies": {
+    "pg": "^8.2.1"
+  },
+  "devDependencies": {
+    "jest": "^26.1.0",
+    "prettier": "^2.0.5"
+  },
+  "scripts": {
+    "test": "NODE_ENV=test jest"
+  }
+}

src/index.js

@@ -0,0 +1,189 @@
+const { Pool } = require('pg')
+const UNIQUE_INDEX_VIOLATION_ERR_CODE = '23505'
+const pool = new Pool({ connectionString: process.env.DATABASE_URL })
+pool.on('acquire', () => {})
+pool.on('remove', () => {})
+pool.on('connect', () => {})
+pool.on('error', (e) => {})
+
+const shutdownPool = async () => {
+  await pool.end()
+}
+
+const findOne = async (tableName, condition) => {
+  let rows = await find(tableName, condition)
+  if (rows && rows.length > 0) {
+    return rows[0]
+  }
+  return null
+}
+
+const find = async (tableName, condition) => {
+  let parts = [`SELECT * FROM ${tableName}`]
+  let conditionQuery = buildConditionSql(condition)
+  parts.push(conditionQuery)
+  let query = parts.join(' ')
+  let dollarValues = Object.keys(condition).map((key) => condition[key])
+  let result = await pool.query(query, dollarValues)
+  return result.rows
+}
+
+const insert = async (tr, tableName, columnValues, returning = ['id']) => {
+  let parts = [`INSERT INTO ${tableName}`]
+  let insertColumns = Object.keys(columnValues)
+  parts.push(`(${insertColumns.join(', ')})`)
+  parts.push('VALUES')
+  let dollars = Object.keys(columnValues).map((_, i) => `$${i + 1}`)
+  parts.push(`(${dollars.join(', ')})`)
+  parts.push(`RETURNING ${returning.join(', ')}`)
+  let dollarValues = Object.keys(columnValues).map((key) => columnValues[key])
+  let query = parts.join(' ')
+  try {
+    let result = await (tr || pool).query(query, dollarValues)
+    if (result.rows && result.rows.length > 0) {
+      return result.rows[0]
+    }
+  } catch (e) {
+    if (e.code && e.code === UNIQUE_INDEX_VIOLATION_ERR_CODE) {
+      throwUniqueIndexViolationError(e)
+    }
+    throw e
+  }
+}
+
+const update = async (tr, tableName, columnValues, condition) => {
+  let parts = [`UPDATE ${tableName} SET`]
+  let updateParts = []
+  Object.keys(columnValues).forEach((columnName, i) => {
+    updateParts.push(`${columnName} = $${i + 1}`)
+  })
+  parts.push(updateParts.join(', '))
+  parts.push(buildConditionSql(condition, updateParts.length))
+  let query = parts.join(' ')
+  let dollarValues = Object.keys(columnValues).map((key) => columnValues[key])
+  if (condition !== {}) {
+    dollarValues = dollarValues.concat(Object.keys(condition).map((key) => condition[key]))
+  }
+  try {
+    await (tr || pool).query(query, dollarValues)
+  } catch (e) {
+    if (e.code && e.code === UNIQUE_INDEX_VIOLATION_ERR_CODE) {
+      throwUniqueIndexViolationError(e)
+    }
+    throw e
+  }
+  return true
+}
+
+const del = async (tr, tableName, condition) => {
+  let parts = [`DELETE FROM ${tableName}`]
+  parts.push(buildConditionSql(condition))
+  let query = parts.join(' ')
+  let dollarValues = Object.keys(condition).map((key) => condition[key])
+  let result = await (tr || pool).query(query, dollarValues)
+  return result.rows
+}
+
+const query = async (tr, sql, dollarValues) => {
+  let result = await (tr || pool).query(sql, dollarValues)
+  return result
+}
+
+const buildConditionSql = (condition, startDollarNumbering = 0) => {
+  if (!condition || Object.keys(condition).length === 0) {
+    return null
+  }
+  let parts = []
+  let conditionParts = []
+  Object.keys(condition).forEach((key, i) => {
+    let value = condition[key]
+    // https://bit.ly/2yNyzoe
+    if (Array.isArray(value)) {
+      conditionParts.push(`${key} = ANY($${startDollarNumbering + i + 1})`)
+    } else {
+      conditionParts.push(`${key} = $${startDollarNumbering + i + 1}`)
+    }
+  })
+  if (conditionParts.length > 0) {
+    parts.push('WHERE')
+    parts.push(conditionParts.join(' AND '))
+  }
+  return parts.join(' ')
+}
+
+const withTransaction = async (cb) => {
+  const client = await pool.connect()
+  try {
+    await client.query('BEGIN')
+    await cb(client)
+    await client.query('COMMIT')
+  } catch (e) {
+    await client.query('ROLLBACK')
+    throw e
+  } finally {
+    client.release()
+  }
+}
+
+const mapToColumns = (attrs, map) => {
+  if (!attrs) {
+    return {}
+  }
+  return Object.keys(attrs).reduce((obj, key) => {
+    const column = map[key]
+    if (!column) {
+      throw new Error(`Unknown attribute: ${key}`)
+    }
+    obj[column] = attrs[key]
+    return obj
+  }, {})
+}
+
+const mapFromColumns = (row, map) => {
+  if (!row) {
+    return null
+  }
+  return Object.keys(map).reduce((obj, key) => {
+    const column = map[key]
+    obj[key] = row[column]
+    return obj
+  }, {})
+}
+
+class UniqueIndexError extends Error {
+  constructor({ table, constraint, detail }) {
+    super(detail)
+    this.table = table
+    this.constraint = constraint
+    this.columns = this.parseColumns(detail)
+  }
+
+  parseColumns(detail) {
+    // error message usually looks like this (in case of a single-column) index violation
+    // Key (email)=([email protected]) already exists.
+    // or like this (in case of a multi-column) index violation
+    // Key (customer_id, display_name)=(cus_JOgWoKqN6pizGN, sub1) already exists.
+    let parts = detail.split('=')
+    parts = parts[0].split(/[\(\)]/)
+    let rawColumns = parts[1]
+    return rawColumns.split(', ')
+  }
+}
+
+function throwUniqueIndexViolationError(e) {
+  throw new UniqueIndexError(e)
+}
+
+module.exports = {
+  shutdownPool,
+  find,
+  findOne,
+  insert,
+  update,
+  del,
+  mapToColumns,
+  mapFromColumns,
+  withTransaction,
+  query,
+  UniqueIndexError,
+}

tests/index.test.js

@@ -0,0 +1,21 @@
+const {UniqueIndexError} = require("..//src/index");
+
+test("it parses single column constraint", () => {
+  let attrs = {
+    table: "test_table",
+    constraint: "test_constraint",
+    detail: "Key (email)=([email protected]) already exists."
+  };
+  let err = new UniqueIndexError(attrs)
+  expect(err.columns).toEqual(["email"]);
+});
+
+test("it parses multiple column constraint", () => {
+  let attrs = {
+    table: "test_table",
+    constraint: "test_constraint",
+    detail: "Key (customer_id, display_name)=(customer1234, Corporation1) already exists."
+  };
+  let err = new UniqueIndexError(attrs)
+  expect(err.columns).toEqual(["customer_id", "display_name"]);
+});