@platformatic/sql-mapper 0.6.1 → 0.8.0

package/lib/entity.js

@@ -3,10 +3,11 @@
 const camelcase = require('camelcase')
 const { singularize } = require('inflected')
 const {
-  toSingular
+  toSingular,
+  tableName
 } = require('./utils')
 
-function createMapper (defaultDb, sql, log, table, fields, primaryKey, relations, queries, autoTimestamp) {
+function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relations, queries, autoTimestamp, schema) {
   const entityName = toSingular(table)
 
   // Fields remapping
@@ -21,6 +22,13 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKey, relations
     return acc
   }, {})
 
+  const primaryKeysTypes = Array.from(primaryKeys).map((key) => {
+    return {
+      key,
+      sqlType: fields[key].sqlType
+    }
+  })
+
   function fixInput (input) {
     const newInput = {}
     for (const key of Object.keys(input)) {
@@ -46,7 +54,7 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKey, relations
     for (const key of Object.keys(output)) {
       let value = output[key]
       const newKey = fieldMapToRetrieve[key]
-      if (key === primaryKey && value !== null && value !== undefined) {
+      if (primaryKeys.has(key) && value !== null && value !== undefined) {
         value = value.toString()
       }
       newOutput[newKey] = value
@@ -62,23 +70,38 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKey, relations
     // args.input is not array
     const fieldsToRetrieve = computeFields(args.fields).map((f) => sql.ident(f))
     const input = fixInput(args.input)
+
+    let hasPrimaryKeys = true
+    for (const key of primaryKeys) {
+      if (input[key] === undefined) {
+        hasPrimaryKeys = false
+        break
+      }
+    }
+
     let now
     if (autoTimestamp && fields.updated_at) {
       now = new Date()
       input.updated_at = now
     }
-    if (input[primaryKey]) { // update
-      const res = await queries.updateOne(db, sql, table, input, primaryKey, fieldsToRetrieve)
-      return fixOutput(res)
-    } else { // insert
-      if (autoTimestamp && fields.inserted_at) {
-        /* istanbul ignore next */
-        now = now || new Date()
-        input.inserted_at = now
+    if (hasPrimaryKeys) { // update
+      const res = await queries.updateOne(db, sql, table, schema, input, primaryKeys, fieldsToRetrieve)
+      if (res) {
+        return fixOutput(res)
       }
-      const res = await queries.insertOne(db, sql, table, input, primaryKey, fields[primaryKey].sqlType.toLowerCase() === 'uuid', fieldsToRetrieve)
-      return fixOutput(res)
+      // If we are here, the record does not exist, so we create it
+      // this is inefficient because it will do 2 queries.
+      // TODO there is a way to do it in one query with DB specific syntax.
     }
+
+    // insert
+    if (autoTimestamp && fields.inserted_at) {
+      /* istanbul ignore next */
+      now = now || new Date()
+      input.inserted_at = now
+    }
+    const res = await queries.insertOne(db, sql, table, schema, input, primaryKeysTypes, fieldsToRetrieve)
+    return fixOutput(res)
   }
 
   async function insert (args) {
@@ -101,14 +124,14 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKey, relations
     /* istanbul ignore next */
     if (queries.insertMany) {
       // We are not fixing the input here because it is done in the query.
-      const res = await queries.insertMany(db, sql, table, inputs, inputToFieldMap, primaryKey, fieldsToRetrieve, fields)
+      const res = await queries.insertMany(db, sql, table, schema, inputs, inputToFieldMap, primaryKeysTypes, fieldsToRetrieve, fields)
       return res.map(fixOutput)
     } else {
       // TODO this can be optimized, we can still use a batch insert if we do not want any fields
       const res = []
       for (let input of inputs) {
         input = fixInput(input)
-        const resOne = await queries.insertOne(db, sql, table, input, primaryKey, fields[primaryKey].sqlType.toLowerCase() === 'uuid', fieldsToRetrieve)
+        const resOne = await queries.insertOne(db, sql, table, schema, input, primaryKeysTypes, fieldsToRetrieve)
         res.push(fixOutput(resOne))
       }
 
@@ -116,6 +139,24 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKey, relations
     }
   }
 
+  async function updateMany (args) {
+    const db = args.tx || defaultDb
+    const fieldsToRetrieve = computeFields(args.fields).map((f) => sql.ident(f))
+    if (args.input === undefined) {
+      throw new Error('Input not provided.')
+    }
+    const input = fixInput(args.input)
+    let now
+    if (autoTimestamp && fields.updated_at) {
+      now = new Date()
+      input.updated_at = now
+    }
+    const criteria = computeCriteria(args)
+
+    const res = await queries.updateMany(db, sql, table, schema, criteria, input, fieldsToRetrieve)
+    return res.map(fixOutput)
+  }
+
   function computeFields (fields) {
     if (!fields) {
       return Object.values(inputToFieldMap)
@@ -147,7 +188,8 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKey, relations
     gt: '>',
     gte: '>=',
     lt: '<',
-    lte: '<='
+    lte: '<=',
+    like: 'LIKE'
   }
 
   function computeCriteria (opts) {
@@ -168,6 +210,14 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKey, relations
           criteria.push(sql`${sql.ident(field)} IS NULL`)
         } else if (operator === '<>' && value[key] === null) {
           criteria.push(sql`${sql.ident(field)} IS NOT NULL`)
+        } else if (operator === 'LIKE') {
+          let leftHand = sql.ident(field)
+          // NOTE: cast fields AS CHAR(64) and TRIM the whitespaces
+          // to prevent errors with fields different than VARCHAR & TEXT
+          if (!['text', 'varchar'].includes(fieldWrap.sqlType)) {
+            leftHand = sql`TRIM(CAST(${sql.ident(field)} AS CHAR(64)))`
+          }
+          criteria.push(sql`${leftHand} LIKE ${value[key]}`)
         } else {
           criteria.push(sql`${sql.ident(field)} ${sql.__dangerous__rawValue(operator)} ${computeCriteriaValue(fieldWrap, value[key])}`)
         }
@@ -197,9 +247,10 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKey, relations
     const db = opts.tx || defaultDb
     const fieldsToRetrieve = computeFields(opts.fields).map((f) => sql.ident(f))
     const criteria = computeCriteria(opts)
+
     let query = sql`
       SELECT ${sql.join(fieldsToRetrieve, sql`, `)}
-      FROM ${sql.ident(table)}
+      FROM ${tableName(sql, table, schema)}
     `
 
     if (criteria.length > 0) {
@@ -232,7 +283,7 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKey, relations
     let totalCountQuery = null
     totalCountQuery = sql`
         SELECT COUNT(*) AS total 
-        FROM ${sql.ident(table)}
+        FROM ${tableName(sql, table, schema)}
       `
     const criteria = computeCriteria(opts)
     if (criteria.length > 0) {
@@ -246,7 +297,7 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKey, relations
     const db = opts.tx || defaultDb
     const fieldsToRetrieve = computeFields(opts.fields).map((f) => sql.ident(f))
     const criteria = computeCriteria(opts)
-    const res = await queries.deleteAll(db, sql, table, criteria, fieldsToRetrieve)
+    const res = await queries.deleteAll(db, sql, table, schema, criteria, fieldsToRetrieve)
     return res.map(fixOutput)
   }
 
@@ -254,8 +305,9 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKey, relations
     name: entityName,
     singularName: camelcase(singularize(table)),
     pluralName: camelcase(table),
-    primaryKey,
+    primaryKeys,
     table,
+    schema,
     fields,
     camelCasedFields,
     fixInput,
@@ -264,28 +316,48 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKey, relations
     count,
     insert,
     save,
-    delete: _delete
+    delete: _delete,
+    updateMany
   }
 }
 
-async function buildEntity (db, sql, log, table, queries, autoTimestamp, ignore) {
+async function buildEntity (db, sql, log, table, queries, autoTimestamp, schema, ignore) {
   // Compute the columns
-  const columns = (await queries.listColumns(db, sql, table)).filter((c) => !ignore[c.column_name])
+  const columns = (await queries.listColumns(db, sql, table, schema)).filter((c) => !ignore[c.column_name])
   const fields = columns.reduce((acc, column) => {
     acc[column.column_name] = {
       sqlType: column.udt_name,
       isNullable: column.is_nullable === 'YES'
     }
+
+    // To get enum values in mysql and mariadb
+    /* istanbul ignore next */
+    if (column.udt_name === 'enum') {
+      acc[column.column_name].enum = column.column_type.match(/'(.+?)'/g).map(enumValue => enumValue.slice(1, enumValue.length - 1))
+    }
+
     if (autoTimestamp && (column.column_name === 'updated_at' || column.column_name === 'inserted_at')) {
       acc[column.column_name].autoTimestamp = true
     }
     return acc
   }, {})
 
+  // To get enum values in pg
+  /* istanbul ignore next */
+  if (db.isPg) {
+    const enums = await queries.listEnumValues(db, sql, table, schema)
+    for (const enumValue of enums) {
+      if (!fields[enumValue.column_name].enum) {
+        fields[enumValue.column_name].enum = [enumValue.enumlabel]
+      } else {
+        fields[enumValue.column_name].enum.push(enumValue.enumlabel)
+      }
+    }
+  }
   const currentRelations = []
 
-  const constraintsList = await queries.listConstraints(db, sql, table)
-  let primaryKey
+  const constraintsList = await queries.listConstraints(db, sql, table, schema)
+  const primaryKeys = new Set()
 
   for (const constraint of constraintsList) {
     const field = fields[constraint.column_name]
@@ -300,12 +372,12 @@ async function buildEntity (db, sql, log, table, queries, autoTimestamp, ignore)
     }
 
     if (constraint.constraint_type === 'PRIMARY KEY') {
-      primaryKey = constraint.column_name
+      primaryKeys.add(constraint.column_name)
       // Check for SQLite typeless PK
       /* istanbul ignore next */
       if (db.isSQLite) {
         const validTypes = ['integer', 'uuid', 'serial']
-        const pkType = fields[primaryKey].sqlType.toLowerCase()
+        const pkType = fields[constraint.column_name].sqlType.toLowerCase()
         if (!validTypes.includes(pkType)) {
           throw new Error(`Invalid Primary Key type. Expected "integer", found "${pkType}"`)
         }
@@ -319,7 +391,7 @@ async function buildEntity (db, sql, log, table, queries, autoTimestamp, ignore)
     }
   }
 
-  const entity = createMapper(db, sql, log, table, fields, primaryKey, currentRelations, queries, autoTimestamp)
+  const entity = createMapper(db, sql, log, table, fields, primaryKeys, currentRelations, queries, autoTimestamp, schema)
   entity.relations = currentRelations
 
   return entity

package/lib/queries/mysql-shared.js

@@ -1,62 +1,117 @@
 'use strict'
 
-async function listTables (db, sql) {
-  const res = await db.query(sql`
-    SELECT TABLE_NAME
-    FROM information_schema.tables
-    WHERE table_schema = (SELECT DATABASE())
-  `)
-  return res.map(r => r.TABLE_NAME)
+const { tableName } = require('../utils')
+
+async function listTables (db, sql, schemas) {
+  if (schemas) {
+    const schemaList = sql.__dangerous__rawValue(schemas.map(s => `'${s}'`))
+    const res = await db.query(sql`
+      SELECT TABLE_SCHEMA, TABLE_NAME
+      FROM information_schema.tables
+      WHERE table_schema in (${schemaList})
+    `)
+    return res.map(r => ({ schema: r.TABLE_SCHEMA, table: r.TABLE_NAME }))
+  } else {
+    const res = await db.query(sql`
+      SELECT TABLE_SCHEMA, TABLE_NAME
+      FROM information_schema.tables
+      WHERE table_schema = (SELECT DATABASE())
+    `)
+    return res.map(r => ({ schema: r.TABLE_SCHEMA, table: r.TABLE_NAME }))
+  }
 }
 
-async function listColumns (db, sql, table) {
-  const res = await db.query(sql`
-    SELECT column_name as column_name, data_type as udt_name, is_nullable as is_nullable
+async function listColumns (db, sql, table, schema) {
+  const query = sql`
+    SELECT column_name as column_name, data_type as udt_name, is_nullable as is_nullable, column_type as column_type
     FROM information_schema.columns
     WHERE table_name = ${table}
-    AND table_schema = (SELECT DATABASE())
-  `)
-  return res
+    AND table_schema = ${schema}
+  `
+  return db.query(query)
 }
 
-async function listConstraints (db, sql, table) {
-  const res = await db.query(sql`
+async function listConstraints (db, sql, table, schema) {
+  const query = sql`
     SELECT TABLE_NAME as table_name, COLUMN_NAME as column_name, CONSTRAINT_TYPE as constraint_type, referenced_table_name AS foreign_table_name, referenced_column_name AS foreign_column_name
     FROM information_schema.table_constraints t
     JOIN information_schema.key_column_usage k
     USING (constraint_name, table_schema, table_name)
     WHERE t.table_name = ${table}
-    AND t.table_schema = (SELECT DATABASE())
-  `)
-
-  return res
+    AND t.table_schema = ${schema}
+    `
+  return db.query(query)
 }
 
-async function updateOne (db, sql, table, input, primaryKey, fieldsToRetrieve) {
+async function updateOne (db, sql, table, schema, input, primaryKeys, fieldsToRetrieve) {
   const pairs = Object.keys(input).map((key) => {
-    const value = input[key]
+    let value = input[key]
+    /* istanbul ignore next */
+    if (value && typeof value === 'object' && !(value instanceof Date)) {
+      value = JSON.stringify(value)
+    }
     return sql`${sql.ident(key)} = ${value}`
   })
+  const where = []
+  for (const key of primaryKeys) {
+    where.push(sql`${sql.ident(key)} = ${input[key]}`)
+  }
   const update = sql`
-    UPDATE ${sql.ident(table)}
+    UPDATE ${tableName(sql, table, schema)}
     SET ${sql.join(pairs, sql`, `)}
-    WHERE ${sql.ident(primaryKey)} = ${sql.value(input[primaryKey])}
+    WHERE ${sql.join(where, sql` AND `)}
   `
   await db.query(update)
 
   const select = sql`
     SELECT ${sql.join(fieldsToRetrieve, sql`, `)}
-    FROM ${sql.ident(table)}
-    WHERE ${sql.ident(primaryKey)} = ${sql.value(input[primaryKey])}
+    FROM ${tableName(sql, table, schema)}
+    WHERE ${sql.join(where, sql` AND `)}
   `
 
   const res = await db.query(select)
   return res[0]
 }
 
+async function updateMany (db, sql, table, schema, criteria, input, fieldsToRetrieve) {
+  const pairs = Object.keys(input).map((key) => {
+    let value = input[key]
+    /* istanbul ignore next */
+    if (value && typeof value === 'object' && !(value instanceof Date)) {
+      value = JSON.stringify(value)
+    }
+    return sql`${sql.ident(key)} = ${value}`
+  })
+
+  const selectIds = sql`
+    SELECT id
+    FROM ${tableName(sql, table, schema)}
+    WHERE ${sql.join(criteria, sql` AND `)}
+  `
+  const resp = await db.query(selectIds)
+  const ids = resp.map(({ id }) => id)
+
+  const update = sql`
+    UPDATE ${tableName(sql, table, schema)}
+    SET ${sql.join(pairs, sql`, `)}
+    WHERE ${sql.join(criteria, sql` AND `)}
+  `
+
+  await db.query(update)
+
+  const select = sql`
+    SELECT ${sql.join(fieldsToRetrieve, sql`, `)}
+    FROM ${tableName(sql, table, schema)}
+    WHERE id IN (${ids});
+  `
+  const res = await db.query(select)
+  return res
+}
+
 module.exports = {
   listTables,
   listColumns,
   listConstraints,
-  updateOne
+  updateOne,
+  updateMany
 }

package/lib/queries/mysql.js

@@ -2,8 +2,9 @@
 
 const { insertPrep } = require('./shared')
 const shared = require('./mysql-shared')
+const { tableName } = require('../utils')
 
-function insertOne (db, sql, table, input, primaryKey, useUUID, fieldsToRetrieve) {
+function insertOne (db, sql, table, schema, input, primaryKeys, fieldsToRetrieve) {
   const keysToSql = Object.keys(input).map((key) => sql.ident(key))
   const keys = sql.join(
     keysToSql,
@@ -11,6 +12,11 @@ function insertOne (db, sql, table, input, primaryKey, useUUID, fieldsToRetrieve
   )
 
   const valuesToSql = Object.keys(input).map((key) => {
+    /* istanbul ignore next */
+    if (input[key] && typeof input[key] === 'object' && !(input[key] instanceof Date)) {
+      // This is a JSON field
+      return sql.value(JSON.stringify(input[key]))
+    }
     return sql.value(input[key])
   })
   const values = sql.join(
@@ -18,55 +24,97 @@ function insertOne (db, sql, table, input, primaryKey, useUUID, fieldsToRetrieve
     sql`, `
   )
 
-  return db.tx(async function (db) {
-    const insert = sql`
-      INSERT INTO ${sql.ident(table)} (${keys})
+  if (primaryKeys.length === 1 && input[primaryKeys[0].key] === undefined) {
+    return db.tx(async function (db) {
+      const insert = sql`
+      INSERT INTO ${tableName(sql, table, schema)} (${keys})
       VALUES(${values})
     `
-    await db.query(insert)
+      await db.query(insert)
 
-    const res2 = await db.query(sql`
+      const res2 = await db.query(sql`
       SELECT ${sql.join(fieldsToRetrieve, sql`, `)}
-      FROM ${sql.ident(table)}
-      WHERE ${sql.ident(primaryKey)} = (
+      FROM ${tableName(sql, table, schema)}
+      WHERE ${sql.ident(primaryKeys[0].key)} = (
         SELECT last_insert_id()
       )
     `)
 
-    return res2[0]
-  })
+      return res2[0]
+    })
+  } else {
+    const where = []
+    for (const { key } of primaryKeys) {
+      // TODO write a test that cover this
+      /* istanbul ignore next */
+      if (!input[key]) {
+        throw new Error(`Missing value for primary key ${key}`)
+      }
+      where.push(sql`${sql.ident(key)} = ${input[key]}`)
+    }
+
+    return db.tx(async function (db) {
+      const insert = sql`
+      INSERT INTO ${tableName(sql, table, schema)} (${keys})
+      VALUES(${values})
+    `
+      await db.query(insert)
+
+      const res2 = await db.query(sql`
+        SELECT ${sql.join(fieldsToRetrieve, sql`, `)}
+        FROM ${tableName(sql, table, schema)}
+        WHERE ${sql.join(where, sql` AND `)}
+      `)
+
+      return res2[0]
+    })
+  }
 }
 
-function insertMany (db, sql, table, inputs, inputToFieldMap, primaryKey, fieldsToRetrieve, fields) {
+function insertMany (db, sql, table, schema, inputs, inputToFieldMap, primaryKeys, fieldsToRetrieve, fields) {
   return db.tx(async function (db) {
     const { keys, values } = insertPrep(inputs, inputToFieldMap, fields, sql)
     const insert = sql`
-      insert into ${sql.ident(table)} (${keys})
+      insert into ${tableName(sql, table, schema)} (${keys})
       values ${sql.join(values, sql`, `)}
     `
 
     await db.query(insert)
 
+    const orderBy = []
+    for (const { key } of primaryKeys) {
+      orderBy.push(sql`${sql.ident(key)} DESC`)
+    }
+
     const res = await db.query(sql`
       SELECT ${sql.join(fieldsToRetrieve, sql`, `)}
-      FROM ${sql.ident(table)}
-      ORDER BY ${sql.ident(primaryKey)} DESC
+      FROM ${tableName(sql, table, schema)}
+      ORDER BY ${sql.join(orderBy, sql`, `)}
       LIMIT ${inputs.length}
     `)
 
     // To make consistent with shared.insertMany
     res.sort(function (a, b) {
-      return a.id - b.id
+      let val = 0
+      for (const { key } of primaryKeys) {
+        val = a[key] - b[key]
+        if (val !== 0) {
+          return val
+        }
+      }
+      // The following should never happen
+      /* istanbul ignore next */
+      return val
     })
     return res
   })
 }
 
-function deleteAll (db, sql, table, criteria, fieldsToRetrieve) {
+function deleteAll (db, sql, table, schema, criteria, fieldsToRetrieve) {
   return db.tx(async function (db) {
     let selectQuery = sql`
       SELECT ${sql.join(fieldsToRetrieve, sql`, `)}
-      FROM ${sql.ident(table)}
+      FROM ${tableName(sql, table, schema)}
     `
     /* istanbul ignore else */
     if (criteria.length > 0) {
@@ -79,7 +127,7 @@ function deleteAll (db, sql, table, criteria, fieldsToRetrieve) {
     const res = await db.query(selectQuery)
 
     let deleteQuery = sql`
-      DELETE FROM ${sql.ident(table)}
+      DELETE FROM ${tableName(sql, table, schema)}
     `
 
     /* istanbul ignore else */

package/lib/queries/pg.js

@@ -1,12 +1,13 @@
 'use strict'
 
 const shared = require('./shared')
+const { tableName } = require('../utils')
 
-async function insertOne (db, sql, table, input, primaryKey, isUuid, fieldsToRetrieve) {
+async function insertOne (db, sql, table, schema, input, primaryKeys, fieldsToRetrieve) {
   const inputKeys = Object.keys(input)
   if (inputKeys.length === 0) {
     const insert = sql`
-      INSERT INTO ${sql.ident(table)}
+      INSERT INTO ${tableName(sql, table, schema)}
       DEFAULT VALUES
       RETURNING ${sql.join(fieldsToRetrieve, sql`, `)}
     `
@@ -14,36 +15,46 @@ async function insertOne (db, sql, table, input, primaryKey, isUuid, fieldsToRet
     return res[0]
   }
 
-  return shared.insertOne(db, sql, table, input, primaryKey, isUuid, fieldsToRetrieve)
+  return shared.insertOne(db, sql, table, schema, input, primaryKeys, fieldsToRetrieve)
 }
 
 module.exports.insertOne = insertOne
 module.exports.deleteAll = shared.deleteAll
 module.exports.insertMany = shared.insertMany
 
-async function listTables (db, sql) {
-  return (await db.query(sql`
-    SELECT tablename
+async function listTables (db, sql, schemas) {
+  if (schemas) {
+    const schemaList = sql.__dangerous__rawValue(schemas.map(s => `'${s}'`))
+    const res = await db.query(sql`
+    SELECT tablename, schemaname
+    FROM pg_catalog.pg_tables
+    WHERE
+      schemaname in (${schemaList})`)
+    return res.map(r => ({ schema: r.schemaname, table: r.tablename }))
+  }
+  const res = await db.query(sql`
+    SELECT tablename, schemaname
     FROM pg_catalog.pg_tables
     WHERE
       schemaname = current_schema()
-    `)).map(t => t.tablename)
+  `)
+  return res.map(r => ({ schema: r.schemaname, table: r.tablename }))
 }
 
 module.exports.listTables = listTables
 
-async function listColumns (db, sql, table) {
+async function listColumns (db, sql, table, schema) {
   return db.query(sql`
     SELECT column_name, udt_name, is_nullable
     FROM information_schema.columns
     WHERE table_name = ${table}
-    AND table_schema = current_schema()
+    AND table_schema = ${schema}
   `)
 }
 
 module.exports.listColumns = listColumns
 
-async function listConstraints (db, sql, table) {
+async function listConstraints (db, sql, table, schema) {
   const query = sql`
     SELECT constraints.*, usage.*, usage2.table_name AS foreign_table_name, usage2.column_name AS foreign_column_name
     FROM information_schema.table_constraints constraints
@@ -52,24 +63,28 @@ async function listConstraints (db, sql, table) {
         AND constraints.table_name = ${table}
       JOIN information_schema.constraint_column_usage usage2
         ON usage.constraint_name = usage2.constraint_name
-        AND usage.table_name = ${table}
+        AND ( usage.table_name = ${table}
+        AND usage.table_schema = ${schema} )
   `
-
   const constraintsList = await db.query(query)
   return constraintsList
 }
 
 module.exports.listConstraints = listConstraints
 
-async function updateOne (db, sql, table, input, primaryKey, fieldsToRetrieve) {
+async function updateOne (db, sql, table, schema, input, primaryKeys, fieldsToRetrieve) {
   const pairs = Object.keys(input).map((key) => {
     const value = input[key]
     return sql`${sql.ident(key)} = ${value}`
   })
+  const where = []
+  for (const key of primaryKeys) {
+    where.push(sql`${sql.ident(key)} = ${input[key]}`)
+  }
   const update = sql`
-    UPDATE ${sql.ident(table)}
+    UPDATE ${tableName(sql, table, schema)}
     SET ${sql.join(pairs, sql`, `)}
-    WHERE ${sql.ident(primaryKey)} = ${sql.value(input[primaryKey])}
+    WHERE ${sql.join(where, sql` AND `)}
     RETURNING ${sql.join(fieldsToRetrieve, sql`, `)}
   `
   const res = await db.query(update)
@@ -77,3 +92,19 @@ async function updateOne (db, sql, table, input, primaryKey, fieldsToRetrieve) {
 }
 
 module.exports.updateOne = updateOne
+
+module.exports.updateMany = shared.updateMany
+
+async function listEnumValues (db, sql, table, schema) {
+  const query = sql`
+    SELECT udt_name, enumlabel, column_name
+    FROM pg_enum e 
+    JOIN pg_type t ON e.enumtypid = t.oid 
+    JOIN information_schema.columns c on c.udt_name = t.typname
+    WHERE table_name = ${table}
+    AND table_schema = ${schema};
+    `
+  return db.query(query)
+}
+
+module.exports.listEnumValues = listEnumValues