@platformatic/sql-mapper 0.6.1 → 0.7.0

package/lib/entity.js

@@ -116,6 +116,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, criteria, input, fieldsToRetrieve)
+    return res.map(fixOutput)
+  }
+
   function computeFields (fields) {
     if (!fields) {
       return Object.values(inputToFieldMap)
@@ -264,7 +282,8 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKey, relations
     count,
     insert,
     save,
-    delete: _delete
+    delete: _delete,
+    updateMany
   }
 }
 
@@ -276,12 +295,30 @@ async function buildEntity (db, sql, log, table, queries, autoTimestamp, ignore)
       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)
+    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)

package/lib/queries/mysql-shared.js

@@ -11,7 +11,7 @@ async function listTables (db, sql) {
 
 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
+    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())
@@ -54,9 +54,41 @@ async function updateOne (db, sql, table, input, primaryKey, fieldsToRetrieve) {
   return res[0]
 }
 
+async function updateMany (db, sql, table, criteria, input, fieldsToRetrieve) {
+  const pairs = Object.keys(input).map((key) => {
+    const value = input[key]
+    return sql`${sql.ident(key)} = ${value}`
+  })
+
+  const selectIds = sql`
+    SELECT id
+    FROM ${sql.ident(table)}
+    WHERE ${sql.join(criteria, sql` AND `)}
+  `
+  const resp = await db.query(selectIds)
+  const ids = resp.map(({ id }) => id)
+
+  const update = sql`
+    UPDATE ${sql.ident(table)}
+    SET ${sql.join(pairs, sql`, `)}
+    WHERE ${sql.join(criteria, sql` AND `)}
+  `
+
+  await db.query(update)
+
+  const select = sql`
+    SELECT ${sql.join(fieldsToRetrieve, sql`, `)}
+    FROM ${sql.ident(table)}
+    WHERE id IN (${ids});
+  `
+  const res = await db.query(select)
+  return res
+}
+
 module.exports = {
   listTables,
   listColumns,
   listConstraints,
-  updateOne
+  updateOne,
+  updateMany
 }

package/lib/queries/pg.js

@@ -77,3 +77,17 @@ async function updateOne (db, sql, table, input, primaryKey, fieldsToRetrieve) {
 }
 
 module.exports.updateOne = updateOne
+
+module.exports.updateMany = shared.updateMany
+
+async function listEnumValues (db, sql, table) {
+  return (await db.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};
+  `))
+}
+
+module.exports.listEnumValues = listEnumValues

package/lib/queries/shared.js

@@ -92,9 +92,25 @@ function insertPrep (inputs, inputToFieldMap, fields, sql) {
   return { keys, values }
 }
 
+async function updateMany (db, sql, table, criteria, input, 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.join(criteria, sql` AND `)}
+    RETURNING ${sql.join(fieldsToRetrieve, sql`, `)}
+    `
+  const res = await db.query(update)
+  return res
+}
+
 module.exports = {
   insertOne,
   insertPrep,
   deleteAll,
-  insertMany
+  insertMany,
+  updateMany
 }

package/lib/queries/sqlite.js

@@ -1,6 +1,7 @@
 'use strict'
 
 const { randomUUID } = require('crypto')
+const shared = require('./shared')
 
 async function listTables (db, sql) {
   const tables = await db.query(sql`
@@ -167,3 +168,5 @@ async function deleteAll (db, sql, table, criteria, fieldsToRetrieve) {
 }
 
 module.exports.deleteAll = deleteAll
+
+module.exports.updateMany = shared.updateMany

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/sql-mapper",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "description": "A data mapper utility for SQL databases",
   "main": "mapper.js",
   "repository": {

package/test/entity.test.js

@@ -2,7 +2,7 @@
 
 const { test } = require('tap')
 
-const { clear, connInfo, isSQLite, isMysql } = require('./helper')
+const { clear, connInfo, isSQLite, isMysql, isPg } = require('./helper')
 const { connect } = require('..')
 const fakeLogger = {
   trace: () => {},
@@ -604,3 +604,37 @@ test('include all fields', async ({ pass, teardown, same, equal }) => {
     }])
   }
 })
+
+test('include possible values of enum columns', { skip: isSQLite }, async ({ same, teardown }) => {
+  async function onDatabaseLoad (db, sql) {
+    await clear(db, sql)
+    teardown(() => db.dispose())
+
+    if (isPg) {
+      await db.query(sql`
+      CREATE TYPE pagetype as enum ('blank', 'non-blank');
+      CREATE TABLE pages (
+        id INTEGER PRIMARY KEY,
+        title VARCHAR(42),
+        type pagetype
+      );`)
+    } else {
+      await db.query(sql`CREATE TABLE pages (
+        id INTEGER PRIMARY KEY,
+        title VARCHAR(42),
+        type ENUM ('blank', 'non-blank')
+      );
+      `)
+    }
+  }
+  const mapper = await connect({
+    connectionString: connInfo.connectionString,
+    log: fakeLogger,
+    onDatabaseLoad,
+    ignore: {},
+    hooks: {}
+  })
+  const pageEntity = mapper.entities.page
+  const typeField = pageEntity.fields.type
+  same(typeField.enum, ['blank', 'non-blank'])
+})

package/test/helper.js

@@ -63,4 +63,9 @@ module.exports.clear = async function (db, sql) {
     await db.query(sql`DROP TABLE versions`)
   } catch {
   }
+
+  try {
+    await db.query(sql`DROP TYPE pagetype`)
+  } catch {
+  }
 }

package/test/updateMany.test.js

@@ -0,0 +1,318 @@
+'use strict'
+
+const { test } = require('tap')
+const { connect } = require('..')
+const { clear, connInfo, isSQLite, isMysql } = require('./helper')
+const { setTimeout } = require('timers/promises')
+const fakeLogger = {
+  trace: () => {},
+  error: () => {}
+}
+
+test('updateMany successful', async ({ pass, teardown, same }) => {
+  const mapper = await connect({
+    ...connInfo,
+    log: fakeLogger,
+    async onDatabaseLoad (db, sql) {
+      teardown(() => db.dispose())
+      pass('onDatabaseLoad called')
+
+      await clear(db, sql)
+
+      if (isSQLite) {
+        await db.query(sql`CREATE TABLE posts (
+          id INTEGER PRIMARY KEY,
+          title VARCHAR(42),
+          long_text TEXT,
+          counter INTEGER
+        );`)
+      } else {
+        await db.query(sql`CREATE TABLE posts (
+          id SERIAL PRIMARY KEY,
+          title VARCHAR(42),
+          long_text TEXT,
+          counter INTEGER
+        );`)
+      }
+    }
+  })
+
+  const entity = mapper.entities.post
+
+  const posts = [{
+    title: 'Dog',
+    longText: 'Foo',
+    counter: 10
+  }, {
+    title: 'Cat',
+    longText: 'Bar',
+    counter: 20
+  }, {
+    title: 'Mouse',
+    longText: 'Baz',
+    counter: 30
+  }, {
+    title: 'Duck',
+    longText: 'A duck tale',
+    counter: 40
+  }]
+
+  await entity.insert({
+    inputs: posts
+  })
+
+  await entity.updateMany({
+    where: {
+      counter: {
+        gte: 30
+      }
+    },
+    input: {
+      title: 'Updated title'
+    }
+  })
+
+  const updatedPosts = await entity.find({})
+
+  same(updatedPosts, [{
+    id: '1',
+    title: 'Dog',
+    longText: 'Foo',
+    counter: 10
+  }, {
+    id: '2',
+    title: 'Cat',
+    longText: 'Bar',
+    counter: 20
+  }, {
+    id: '3',
+    title: 'Updated title',
+    longText: 'Baz',
+    counter: 30
+  }, {
+    id: '4',
+    title: 'Updated title',
+    longText: 'A duck tale',
+    counter: 40
+  }])
+})
+
+test('updateMany will return the updated values', async ({ pass, teardown, same }) => {
+  const mapper = await connect({
+    ...connInfo,
+    log: fakeLogger,
+    async onDatabaseLoad (db, sql) {
+      teardown(() => db.dispose())
+      pass('onDatabaseLoad called')
+
+      await clear(db, sql)
+
+      if (isSQLite) {
+        await db.query(sql`CREATE TABLE posts (
+          id INTEGER PRIMARY KEY,
+          title VARCHAR(42),
+          long_text TEXT,
+          counter INTEGER
+        );`)
+      } else {
+        await db.query(sql`CREATE TABLE posts (
+          id SERIAL PRIMARY KEY,
+          title VARCHAR(42),
+          long_text TEXT,
+          counter INTEGER
+        );`)
+      }
+    }
+  })
+
+  const entity = mapper.entities.post
+
+  const posts = [{
+    title: 'Dog',
+    longText: 'Foo',
+    counter: 10
+  }, {
+    title: 'Cat',
+    longText: 'Bar',
+    counter: 20
+  }, {
+    title: 'Mouse',
+    longText: 'Baz',
+    counter: 30
+  }, {
+    title: 'Duck',
+    longText: 'A duck tale',
+    counter: 40
+  }]
+
+  await entity.insert({
+    inputs: posts
+  })
+
+  const updatedPosts = await entity.updateMany({
+    where: {
+      counter: {
+        gte: 30
+      }
+    },
+    input: {
+      title: 'Updated title'
+    },
+    fields: ['id', 'counter']
+  })
+
+  same(updatedPosts, [{
+    id: '3',
+    counter: 30
+  }, {
+    id: '4',
+    counter: 40
+  }])
+})
+
+test('updateMany missing input', async ({ pass, teardown, rejects }) => {
+  const mapper = await connect({
+    ...connInfo,
+    log: fakeLogger,
+    async onDatabaseLoad (db, sql) {
+      teardown(() => db.dispose())
+      pass('onDatabaseLoad called')
+
+      await clear(db, sql)
+
+      if (isSQLite) {
+        await db.query(sql`CREATE TABLE posts (
+          id INTEGER PRIMARY KEY,
+          title VARCHAR(42),
+          long_text TEXT,
+          counter INTEGER
+        );`)
+      } else {
+        await db.query(sql`CREATE TABLE posts (
+          id SERIAL PRIMARY KEY,
+          title VARCHAR(42),
+          long_text TEXT,
+          counter INTEGER
+        );`)
+      }
+    }
+  })
+
+  const entity = mapper.entities.post
+
+  const posts = [{
+    title: 'Dog',
+    longText: 'Foo',
+    counter: 10
+  }, {
+    title: 'Cat',
+    longText: 'Bar',
+    counter: 20
+  }, {
+    title: 'Mouse',
+    longText: 'Baz',
+    counter: 30
+  }, {
+    title: 'Duck',
+    longText: 'A duck tale',
+    counter: 40
+  }]
+
+  await entity.insert({
+    inputs: posts
+  })
+
+  rejects(entity.updateMany({
+    where: {
+      counter: {
+        gte: 30
+      }
+    }
+  }), new Error('Input not provided.'))
+})
+
+test('updateMany successful and update updated_at', async ({ pass, teardown, same, notSame }) => {
+  const mapper = await connect({
+    ...connInfo,
+    autoTimestamp: true,
+    log: fakeLogger,
+    async onDatabaseLoad (db, sql) {
+      teardown(() => db.dispose())
+      pass('onDatabaseLoad called')
+
+      await clear(db, sql)
+
+      if (isSQLite) {
+        await db.query(sql`CREATE TABLE posts (
+          id INTEGER PRIMARY KEY,
+          title VARCHAR(42),
+          long_text TEXT,
+          counter INTEGER,
+          inserted_at TIMESTAMP,
+          updated_at TIMESTAMP
+        );`)
+      } else if (isMysql) {
+        await db.query(sql`CREATE TABLE posts (
+          id SERIAL PRIMARY KEY,
+          title VARCHAR(42),
+          long_text TEXT,
+          counter INTEGER,
+          inserted_at TIMESTAMP NULL DEFAULT NULL,
+          updated_at TIMESTAMP NULL DEFAULT NULL
+        );`)
+      } else {
+        await db.query(sql`CREATE TABLE posts (
+          id SERIAL PRIMARY KEY,
+          title VARCHAR(42),
+          long_text TEXT,
+          counter INTEGER,
+          inserted_at TIMESTAMP,
+          updated_at TIMESTAMP
+        );`)
+      }
+    }
+  })
+
+  const entity = mapper.entities.post
+
+  const posts = [{
+    title: 'Dog',
+    longText: 'Foo',
+    counter: 10
+  }, {
+    title: 'Cat',
+    longText: 'Bar',
+    counter: 20
+  }, {
+    title: 'Mouse',
+    longText: 'Baz',
+    counter: 30
+  }, {
+    title: 'Duck',
+    longText: 'A duck tale',
+    counter: 40
+  }]
+
+  await entity.insert({
+    inputs: posts
+  })
+  const createdPost3 = (await entity.find({ where: { id: { eq: '3' } } }))[0]
+
+  await setTimeout(1000) // await 1s
+
+  await entity.updateMany({
+    where: {
+      counter: {
+        gte: 30
+      }
+    },
+    input: {
+      title: 'Updated title'
+    }
+  })
+
+  const updatedPost3 = (await entity.find({ where: { id: { eq: '3' } } }))[0]
+  same(updatedPost3.title, 'Updated title')
+  same(createdPost3.insertedAt, updatedPost3.insertedAt)
+  notSame(createdPost3.updatedAt, updatedPost3.updatedAt)
+})