@platformatic/sql-mapper 0.0.23

package/README.md

@@ -0,0 +1,13 @@
+# @platformatic/sql-mapper
+
+Check out the full documentation on [our website](https://oss.platformatic.dev/docs/reference/sql-mapper/introduction).
+
+## Install
+
+```sh
+npm install @platformatic/sql-mapper
+```
+
+## License
+
+Apache 2.0

package/lib/entity.js

@@ -0,0 +1,287 @@
+'use strict'
+
+const camelcase = require('camelcase')
+const { singularize } = require('inflected')
+const {
+  toSingular
+} = require('./utils')
+
+function createMapper (db, sql, log, table, fields, primaryKey, relations, queries, autoTimestamp) {
+  const entityName = toSingular(table)
+
+  // Fields remapping
+  const fieldMapToRetrieve = {}
+  const inputToFieldMap = {}
+  const camelCasedFields = Object.keys(fields).reduce((acc, key) => {
+    const camel = camelcase(key)
+    acc[camel] = fields[key]
+    fieldMapToRetrieve[key] = camel
+    inputToFieldMap[camel] = key
+    fields[key].camelcase = camel
+    return acc
+  }, {})
+  const alwaysRetrieve = relations.map((relation) => relation.column_name)
+
+  function fixInput (input) {
+    const newInput = {}
+    for (const key of Object.keys(input)) {
+      const value = input[key]
+      let newKey = inputToFieldMap[key]
+      if (newKey === undefined) {
+        if (fields[key] !== undefined) {
+          newKey = key
+        } else {
+          throw new Error(`Unknown field ${key}`)
+        }
+      }
+      newInput[newKey] = value
+    }
+    return newInput
+  }
+
+  function fixOutput (output) {
+    if (!output) {
+      return output
+    }
+    const newOutput = {}
+    for (const key of Object.keys(output)) {
+      let value = output[key]
+      const newKey = fieldMapToRetrieve[key]
+      if (key === primaryKey && value !== null && value !== undefined) {
+        value = value.toString()
+      }
+      newOutput[newKey] = value
+    }
+    return newOutput
+  }
+
+  async function save (args) {
+    if (args.input === undefined) {
+      throw new Error('Input not provided.')
+    }
+    // args.input is not array
+    const fieldsToRetrieve = computeFields(args.fields).map((f) => sql.ident(f))
+    const input = fixInput(args.input)
+    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
+      }
+      const res = await queries.insertOne(db, sql, table, input, primaryKey, fields[primaryKey].sqlType.toLowerCase() === 'uuid', fieldsToRetrieve)
+      return fixOutput(res)
+    }
+  }
+
+  async function insert (args) {
+    const fieldsToRetrieve = computeFields(args.fields).map((f) => sql.ident(f))
+    const inputs = args.inputs
+    // This else is skipped on MySQL because of https://github.com/ForbesLindesay/atdatabases/issues/221
+    /* istanbul ignore else */
+    if (autoTimestamp) {
+      const now = new Date()
+      for (const input of inputs) {
+        if (fields.inserted_at) {
+          input.insertedAt = now
+        }
+        if (fields.updated_at) {
+          input.updatedAt = now
+        }
+      }
+    }
+    /* 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)
+      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)
+        res.push(fixOutput(resOne))
+      }
+
+      return res
+    }
+  }
+
+  function computeFields (fields) {
+    if (!fields) {
+      return Object.values(inputToFieldMap)
+    }
+
+    const requestedFields = fields.map((field) => inputToFieldMap[field])
+    const set = new Set([...alwaysRetrieve, ...requestedFields])
+    set.delete(undefined)
+    const fieldsToRetrieve = [...set]
+    return fieldsToRetrieve
+  }
+
+  const whereMap = {
+    eq: '=',
+    in: 'IN',
+    nin: 'NOT IN',
+    neq: '<>',
+    gt: '>',
+    gte: '>=',
+    lt: '<',
+    lte: '<='
+  }
+
+  function computeCriteria (opts) {
+    const where = opts.where || {}
+    const criteria = []
+    for (const key of Object.keys(where)) {
+      const value = where[key]
+      const field = inputToFieldMap[key]
+      for (const key of Object.keys(value)) {
+        const operator = whereMap[key]
+        /* istanbul ignore next */
+        if (!operator) {
+          // This should never happen
+          throw new Error(`Unsupported where clause ${JSON.stringify(where[key])}`)
+        }
+        const fieldWrap = fields[field]
+        criteria.push(sql`${sql.ident(field)} ${sql.__dangerous__rawValue(operator)} ${computeCriteriaValue(fieldWrap, value[key])}`)
+      }
+    }
+    return criteria
+  }
+
+  function computeCriteriaValue (fieldWrap, value) {
+    if (Array.isArray(value)) {
+      return sql`(${sql.join(
+        value.map((v) => computeCriteriaValue(fieldWrap, v)),
+        sql`, `
+      )})`
+    }
+
+    /* istanbul ignore next */
+    if (fieldWrap.sqlType === 'int4' || fieldWrap.sqlType === 'int2' || fieldWrap.sqlType === 'float8' || fieldWrap.sqlType === 'float4') {
+      // This cat is needed in PostgreSQL
+      return sql`${Number(value)}`
+    } else {
+      return sql`${value}`
+    }
+  }
+
+  async function find (opts = {}) {
+    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)}
+    `
+
+    if (criteria.length > 0) {
+      query = sql`${query} WHERE ${sql.join(criteria, sql` AND `)}`
+    }
+
+    if (opts.orderBy && opts.orderBy.length > 0) {
+      const orderBy = opts.orderBy.map((order) => {
+        const field = inputToFieldMap[order.field]
+        return sql`${sql.ident(field)} ${sql.__dangerous__rawValue(order.direction)}`
+      })
+      query = sql`${query} ORDER BY ${sql.join(orderBy, sql`, `)}`
+    }
+
+    if (opts.limit && opts.offset !== undefined) {
+      query = sql`${query} LIMIT ${opts.limit} OFFSET ${opts.offset}`
+    }
+
+    const res = await db.query(query)
+    return res.map(fixOutput)
+  }
+
+  async function _delete (opts) {
+    const fieldsToRetrieve = computeFields(opts.fields).map((f) => sql.ident(f))
+    const criteria = computeCriteria(opts)
+    const res = await queries.deleteAll(db, sql, table, criteria, fieldsToRetrieve)
+    return res.map(fixOutput)
+  }
+
+  return {
+    name: entityName,
+    singularName: camelcase(singularize(table)),
+    pluralName: camelcase(table),
+    primaryKey,
+    table,
+    fields,
+    camelCasedFields,
+    fixInput,
+    fixOutput,
+    find,
+    insert,
+    save,
+    delete: _delete
+  }
+}
+
+async function buildEntity (db, sql, log, table, queries, autoTimestamp, ignore) {
+  // Compute the columns
+  const columns = (await queries.listColumns(db, sql, table)).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'
+    }
+    if (autoTimestamp && (column.column_name === 'updated_at' || column.column_name === 'inserted_at')) {
+      acc[column.column_name].autoTimestamp = true
+    }
+    return acc
+  }, {})
+
+  const currentRelations = []
+
+  const constraintsList = await queries.listConstraints(db, sql, table)
+  let primaryKey
+
+  for (const constraint of constraintsList) {
+    const field = fields[constraint.column_name]
+
+    /* istanbul ignore next */
+    if (!field) {
+      // This should never happen
+      log.warn({
+        constraint
+      }, `No field for ${constraint.column_name}`)
+      continue
+    }
+
+    if (constraint.constraint_type === 'PRIMARY KEY') {
+      primaryKey = 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()
+        if (!validTypes.includes(pkType)) {
+          throw new Error(`Invalid Primary Key type. Expected "integer", found "${pkType}"`)
+        }
+      }
+      field.primaryKey = true
+    }
+
+    if (constraint.constraint_type === 'FOREIGN KEY') {
+      field.foreignKey = true
+      currentRelations.push(constraint)
+    }
+  }
+
+  const entity = createMapper(db, sql, log, table, fields, primaryKey, currentRelations, queries, autoTimestamp)
+  entity.relations = currentRelations
+
+  return entity
+}
+
+module.exports = buildEntity

package/lib/queries/index.js

@@ -0,0 +1,23 @@
+'use strict'
+
+/* istanbul ignore file */
+
+const obj = {}
+
+Object.defineProperty(obj, 'pg', {
+  get: () => require('./pg')
+})
+
+Object.defineProperty(obj, 'mysql', {
+  get: () => require('./mysql')
+})
+
+Object.defineProperty(obj, 'mariadb', {
+  get: () => require('./mariadb')
+})
+
+Object.defineProperty(obj, 'sqlite', {
+  get: () => require('./sqlite')
+})
+
+module.exports = obj

package/lib/queries/mariadb.js

@@ -0,0 +1,11 @@
+'use strict'
+
+const shared = require('./shared')
+const mysql = require('./mysql-shared')
+
+module.exports = {
+  ...mysql,
+  insertOne: shared.insertOne,
+  insertMany: shared.insertMany,
+  deleteAll: shared.deleteAll
+}

package/lib/queries/mysql-shared.js

@@ -0,0 +1,62 @@
+'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)
+}
+
+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
+    FROM information_schema.columns
+    WHERE table_name = ${table}
+    AND table_schema = (SELECT DATABASE())
+  `)
+  return res
+}
+
+async function listConstraints (db, sql, table) {
+  const res = await db.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
+}
+
+async function updateOne (db, sql, table, input, primaryKey, fieldsToRetrieve) {
+  const pairs = Object.keys(input).map((key) => {
+    const value = input[key]
+    return sql`${sql.ident(key)} = ${value}`
+  })
+  const update = sql`
+    UPDATE ${sql.ident(table)}
+    SET ${sql.join(pairs, sql`, `)}
+    WHERE ${sql.ident(primaryKey)} = ${sql.value(input[primaryKey])}
+  `
+  await db.query(update)
+
+  const select = sql`
+    SELECT ${sql.join(fieldsToRetrieve, sql`, `)}
+    FROM ${sql.ident(table)}
+    WHERE ${sql.ident(primaryKey)} = ${sql.value(input[primaryKey])}
+  `
+
+  const res = await db.query(select)
+  return res[0]
+}
+
+module.exports = {
+  listTables,
+  listColumns,
+  listConstraints,
+  updateOne
+}

package/lib/queries/mysql.js

@@ -0,0 +1,104 @@
+'use strict'
+
+const { insertPrep } = require('./shared')
+const shared = require('./mysql-shared')
+
+function insertOne (db, sql, table, input, primaryKey, useUUID, fieldsToRetrieve) {
+  const keysToSql = Object.keys(input).map((key) => sql.ident(key))
+  const keys = sql.join(
+    keysToSql,
+    sql`, `
+  )
+
+  const valuesToSql = Object.keys(input).map((key) => {
+    return sql.value(input[key])
+  })
+  const values = sql.join(
+    valuesToSql,
+    sql`, `
+  )
+
+  return db.tx(async function (db) {
+    const insert = sql`
+      INSERT INTO ${sql.ident(table)} (${keys})
+      VALUES(${values})
+    `
+    await db.query(insert)
+
+    const res2 = await db.query(sql`
+      SELECT ${sql.join(fieldsToRetrieve, sql`, `)}
+      FROM ${sql.ident(table)}
+      WHERE ${sql.ident(primaryKey)} = (
+        SELECT last_insert_id()
+      )
+    `)
+
+    return res2[0]
+  })
+}
+
+function insertMany (db, sql, table, inputs, inputToFieldMap, primaryKey, 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})
+      values ${sql.join(values, sql`, `)}
+    `
+
+    await db.query(insert)
+
+    const res = await db.query(sql`
+      SELECT ${sql.join(fieldsToRetrieve, sql`, `)}
+      FROM ${sql.ident(table)}
+      ORDER BY ${sql.ident(primaryKey)} DESC
+      LIMIT ${inputs.length}
+    `)
+
+    // To make consistent with shared.insertMany
+    res.sort(function (a, b) {
+      return a.id - b.id
+    })
+    return res
+  })
+}
+
+function deleteAll (db, sql, table, criteria, fieldsToRetrieve) {
+  return db.tx(async function (db) {
+    let selectQuery = sql`
+      SELECT ${sql.join(fieldsToRetrieve, sql`, `)}
+      FROM ${sql.ident(table)}
+    `
+    /* istanbul ignore else */
+    if (criteria.length > 0) {
+      selectQuery = sql`
+        ${selectQuery}
+        WHERE ${sql.join(criteria, sql` AND `)}
+      `
+    }
+
+    const res = await db.query(selectQuery)
+
+    let deleteQuery = sql`
+      DELETE FROM ${sql.ident(table)}
+    `
+
+    /* istanbul ignore else */
+    if (criteria.length > 0) {
+      deleteQuery = sql`
+        ${deleteQuery}
+        WHERE ${sql.join(criteria, sql` AND `)}
+      `
+    }
+
+    await db.query(deleteQuery)
+
+    return res
+  })
+}
+
+module.exports = {
+  ...shared,
+  insertOne,
+  insertMany,
+  deleteAll
+}

package/lib/queries/pg.js

@@ -0,0 +1,79 @@
+'use strict'
+
+const shared = require('./shared')
+
+async function insertOne (db, sql, table, input, primaryKey, isUuid, fieldsToRetrieve) {
+  const inputKeys = Object.keys(input)
+  if (inputKeys.length === 0) {
+    const insert = sql`
+      INSERT INTO ${sql.ident(table)}
+      DEFAULT VALUES
+      RETURNING ${sql.join(fieldsToRetrieve, sql`, `)}
+    `
+    const res = await db.query(insert)
+    return res[0]
+  }
+
+  return shared.insertOne(db, sql, table, input, primaryKey, isUuid, 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
+    FROM pg_catalog.pg_tables
+    WHERE
+      schemaname = current_schema()
+    `)).map(t => t.tablename)
+}
+
+module.exports.listTables = listTables
+
+async function listColumns (db, sql, table) {
+  return db.query(sql`
+    SELECT column_name, udt_name, is_nullable
+    FROM information_schema.columns
+    WHERE table_name = ${table}
+    AND table_schema = current_schema()
+  `)
+}
+
+module.exports.listColumns = listColumns
+
+async function listConstraints (db, sql, table) {
+  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
+      JOIN information_schema.key_column_usage usage
+        ON constraints.constraint_name = usage.constraint_name
+        AND constraints.table_name = ${table}
+      JOIN information_schema.constraint_column_usage usage2
+        ON usage.constraint_name = usage2.constraint_name
+        AND usage.table_name = ${table}
+  `
+
+  const constraintsList = await db.query(query)
+  return constraintsList
+}
+
+module.exports.listConstraints = listConstraints
+
+async function updateOne (db, sql, table, input, primaryKey, fieldsToRetrieve) {
+  const pairs = Object.keys(input).map((key) => {
+    const value = input[key]
+    return sql`${sql.ident(key)} = ${value}`
+  })
+  const update = sql`
+    UPDATE ${sql.ident(table)}
+    SET ${sql.join(pairs, sql`, `)}
+    WHERE ${sql.ident(primaryKey)} = ${sql.value(input[primaryKey])}
+    RETURNING ${sql.join(fieldsToRetrieve, sql`, `)}
+  `
+  const res = await db.query(update)
+  return res[0]
+}
+
+module.exports.updateOne = updateOne

package/lib/queries/shared.js

@@ -0,0 +1,100 @@
+'use strict'
+
+/* istanbul ignore file */
+
+async function insertOne (db, sql, table, input, primaryKey, isUuid, fieldsToRetrieve) {
+  const inputKeys = Object.keys(input)
+  if (inputKeys.length === 0) {
+    const insert = sql`
+      INSERT INTO ${sql.ident(table)}
+      ()
+      VALUES ()
+      RETURNING ${sql.join(fieldsToRetrieve, sql`, `)}
+    `
+    const res = await db.query(insert)
+    return res[0]
+  }
+
+  const keys = sql.join(
+    inputKeys.map((key) => sql.ident(key)),
+    sql`, `
+  )
+  const values = sql.join(
+    Object.keys(input).map((key) => sql.value(input[key])),
+    sql`, `
+  )
+  const insert = sql`
+    INSERT INTO ${sql.ident(table)} (${keys})
+    VALUES (${values})
+    RETURNING ${sql.join(fieldsToRetrieve, sql`, `)}
+  `
+  const res = await db.query(insert)
+  return res[0]
+}
+
+async function deleteAll (db, sql, table, criteria, fieldsToRetrieve) {
+  let query = sql`
+      DELETE FROM ${sql.ident(table)}
+    `
+
+  if (criteria.length > 0) {
+    query = sql`${query} WHERE ${sql.join(criteria, sql` AND `)}`
+  }
+
+  query = sql`${query} RETURNING ${sql.join(fieldsToRetrieve, sql`, `)}`
+  const res = await db.query(query)
+  return res
+}
+
+async function insertMany (db, sql, table, inputs, inputToFieldMap, primaryKey, fieldsToRetrieve, fields) {
+  const { keys, values } = insertPrep(inputs, inputToFieldMap, fields, sql)
+  const insert = sql`
+    insert into ${sql.ident(table)} (${keys})
+    values ${sql.join(values, sql`, `)}
+    returning ${sql.join(fieldsToRetrieve, sql`, `)}
+  `
+
+  const res = await db.query(insert)
+  return res
+}
+
+function insertPrep (inputs, inputToFieldMap, fields, sql) {
+  const inputSet = new Set()
+  const values = []
+  for (const input of inputs) {
+    const inputValues = []
+    for (const key of Object.keys(input)) {
+      let newKey = key
+      if (inputToFieldMap[key] === undefined) {
+        if (fields[key] === undefined) {
+          throw new Error('Unknown field ' + key)
+        }
+      } else {
+        newKey = inputToFieldMap[key]
+      }
+
+      inputSet.add(newKey)
+
+      const value = input[key] || input[newKey]
+      inputValues.push(sql.value(value))
+    }
+
+    values.push(sql` (${sql.join(
+      inputValues,
+      sql`, `
+    )})`)
+  }
+  const inputKeys = Array.from(inputSet)
+  const keys = sql.join(
+    inputKeys.map((key) => sql.ident(key)),
+    sql`, `
+  )
+  return { keys, values }
+}
+
+module.exports = {
+  insertOne,
+  insertPrep,
+  deleteAll,
+  insertMany
+}