@platformatic/sql-mapper 3.4.1 → 3.5.1

package/lib/queries/mariadb.js

@@ -1,11 +1,2 @@
-'use strict'
-
-const shared = require('./shared')
-const mysql = require('./mysql-shared')
-
-module.exports = {
-  ...mysql,
-  insertOne: shared.insertOne,
-  insertMany: shared.insertMany,
-  deleteAll: shared.deleteAll,
-}
+export { listColumns, listConstraints, listTables, updateMany, updateOne } from './mysql-shared.js'
+export { deleteAll, insertMany, insertOne } from './shared.js'

package/lib/queries/mysql-shared.js

@@ -1,8 +1,6 @@
-'use strict'
+import { tableName } from '../utils.js'
 
-const { tableName } = require('../utils')
-
-async function listTables (db, sql, schemas) {
+export async function listTables (db, sql, schemas) {
   if (schemas) {
     const schemaList = sql.__dangerous__rawValue(schemas.map(s => `'${s}'`))
     const res = await db.query(sql`
@@ -21,7 +19,7 @@ async function listTables (db, sql, schemas) {
   }
 }
 
-async function listColumns (db, sql, table, schema) {
+export 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, extra as is_generated
     FROM information_schema.columns
@@ -31,7 +29,7 @@ async function listColumns (db, sql, table, schema) {
   return db.query(query)
 }
 
-async function listConstraints (db, sql, table, schema) {
+export async function listConstraints (db, sql, table, schema) {
   const query = sql`
     SELECT TABLE_NAME as table_name, TABLE_SCHEMA as table_schema, COLUMN_NAME as column_name, CONSTRAINT_TYPE as constraint_type, referenced_table_name AS foreign_table_name, referenced_table_schema AS foreign_table_schema, referenced_column_name AS foreign_column_name
     FROM information_schema.table_constraints t
@@ -43,8 +41,8 @@ async function listConstraints (db, sql, table, schema) {
   return db.query(query)
 }
 
-async function updateOne (db, sql, table, schema, input, primaryKeys, fieldsToRetrieve) {
-  const pairs = Object.keys(input).map((key) => {
+export async function updateOne (db, sql, table, schema, input, primaryKeys, fieldsToRetrieve) {
+  const pairs = Object.keys(input).map(key => {
     let value = input[key]
     /* istanbul ignore next */
     if (value && typeof value === 'object' && !(value instanceof Date)) {
@@ -73,8 +71,8 @@ async function updateOne (db, sql, table, schema, input, primaryKeys, fieldsToRe
   return res[0]
 }
 
-async function updateMany (db, sql, table, schema, criteria, input, fieldsToRetrieve) {
-  const pairs = Object.keys(input).map((key) => {
+export 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)) {
@@ -108,12 +106,4 @@ async function updateMany (db, sql, table, schema, criteria, input, fieldsToRetr
   return res
 }
 
-module.exports = {
-  listTables,
-  listColumns,
-  listConstraints,
-  updateOne,
-  updateMany,
-}
-
-module.exports.hasILIKE = false
+export const hasILIKE = false

package/lib/queries/mysql.js

@@ -1,18 +1,14 @@
-'use strict'
+import { MissingValueForPrimaryKeyError } from '../errors.js'
+import { tableName } from '../utils.js'
+import { insertPrep } from './shared.js'
 
-const { insertPrep } = require('./shared')
-const shared = require('./mysql-shared')
-const { tableName } = require('../utils')
-const errors = require('../errors')
+export * from './mysql-shared.js'
 
-function insertOne (db, sql, table, schema, input, primaryKeys, fieldsToRetrieve) {
-  const keysToSql = Object.keys(input).map((key) => sql.ident(key))
-  const keys = sql.join(
-    keysToSql,
-    sql`, `
-  )
+export function insertOne (db, sql, table, schema, input, primaryKeys, fieldsToRetrieve) {
+  const keysToSql = Object.keys(input).map(key => sql.ident(key))
+  const keys = sql.join(keysToSql, sql`, `)
 
-  const valuesToSql = Object.keys(input).map((key) => {
+  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
@@ -20,10 +16,7 @@ function insertOne (db, sql, table, schema, input, primaryKeys, fieldsToRetrieve
     }
     return sql.value(input[key])
   })
-  const values = sql.join(
-    valuesToSql,
-    sql`, `
-  )
+  const values = sql.join(valuesToSql, sql`, `)
 
   if (primaryKeys.length === 1 && input[primaryKeys[0].key] === undefined) {
     return db.tx(async function (db) {
@@ -49,7 +42,7 @@ function insertOne (db, sql, table, schema, input, primaryKeys, fieldsToRetrieve
       // TODO write a test that cover this
       /* istanbul ignore next */
       if (!input[key]) {
-        throw new errors.MissingValueForPrimaryKeyError(key)
+        throw new MissingValueForPrimaryKeyError(key)
       }
       where.push(sql`${sql.ident(key)} = ${input[key]}`)
     }
@@ -72,7 +65,7 @@ function insertOne (db, sql, table, schema, input, primaryKeys, fieldsToRetrieve
   }
 }
 
-function insertMany (db, sql, table, schema, inputs, inputToFieldMap, primaryKeys, fieldsToRetrieve, fields) {
+export 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`
@@ -111,7 +104,7 @@ function insertMany (db, sql, table, schema, inputs, inputToFieldMap, primaryKey
   })
 }
 
-function deleteAll (db, sql, table, schema, criteria, fieldsToRetrieve) {
+export function deleteAll (db, sql, table, schema, criteria, fieldsToRetrieve) {
   return db.tx(async function (db) {
     let selectQuery = sql`
       SELECT ${sql.join(fieldsToRetrieve, sql`, `)}
@@ -144,10 +137,3 @@ function deleteAll (db, sql, table, schema, criteria, fieldsToRetrieve) {
     return res
   })
 }
-
-module.exports = {
-  ...shared,
-  insertOne,
-  insertMany,
-  deleteAll,
-}

package/lib/queries/pg.js

@@ -1,9 +1,8 @@
-'use strict'
+import { tableName } from '../utils.js'
+import { insertOne as sharedInsertOne } from './shared.js'
+export { deleteAll, insertMany, updateMany } from './shared.js'
 
-const shared = require('./shared')
-const { tableName } = require('../utils')
-
-async function insertOne (db, sql, table, schema, input, primaryKeys, fieldsToRetrieve) {
+export async function insertOne (db, sql, table, schema, input, primaryKeys, fieldsToRetrieve) {
   const inputKeys = Object.keys(input)
   if (inputKeys.length === 0) {
     const insert = sql`
@@ -14,14 +13,10 @@ async function insertOne (db, sql, table, schema, input, primaryKeys, fieldsToRe
     const res = await db.query(insert)
     return res[0]
   }
-  return shared.insertOne(db, sql, table, schema, input, primaryKeys, fieldsToRetrieve)
+  return sharedInsertOne(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, schemas) {
+export async function listTables (db, sql, schemas) {
   if (schemas) {
     const schemaList = sql.__dangerous__rawValue(schemas.map(s => `'${s}'`))
     const res = await db.query(sql`
@@ -40,9 +35,7 @@ async function listTables (db, sql, schemas) {
   return res.map(r => ({ schema: r.schemaname, table: r.tablename }))
 }
 
-module.exports.listTables = listTables
-
-async function listColumns (db, sql, table, schema) {
+export async function listColumns (db, sql, table, schema) {
   /*
   return db.query(sql`
     SELECT column_name, udt_name, is_nullable, is_generated
@@ -71,9 +64,7 @@ async function listColumns (db, sql, table, schema) {
   return res
 }
 
-module.exports.listColumns = listColumns
-
-async function listConstraints (db, sql, table, schema) {
+export 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, usage2.table_schema AS foreign_table_schema
     FROM information_schema.table_constraints constraints
@@ -89,10 +80,8 @@ async function listConstraints (db, sql, table, schema) {
   return constraintsList
 }
 
-module.exports.listConstraints = listConstraints
-
-async function updateOne (db, sql, table, schema, input, primaryKeys, fieldsToRetrieve) {
-  const pairs = Object.keys(input).map((key) => {
+export 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}`
   })
@@ -110,11 +99,7 @@ async function updateOne (db, sql, table, schema, input, primaryKeys, fieldsToRe
   return res[0]
 }
 
-module.exports.updateOne = updateOne
-
-module.exports.updateMany = shared.updateMany
-
-async function listEnumValues (db, sql, table, schema) {
+export async function listEnumValues (db, sql, table, schema) {
   const query = sql`
     SELECT udt_name, enumlabel, column_name
     FROM pg_enum e 
@@ -126,6 +111,4 @@ async function listEnumValues (db, sql, table, schema) {
   return db.query(query)
 }
 
-module.exports.listEnumValues = listEnumValues
-
-module.exports.hasILIKE = true
+export const hasILIKE = true

package/lib/queries/shared.js

@@ -1,11 +1,9 @@
-'use strict'
-
-const { tableName } = require('../utils')
-const errors = require('../errors')
+import { UnknownFieldError } from '../errors.js'
+import { tableName } from '../utils.js'
 
 /* istanbul ignore file */
 
-async function insertOne (db, sql, table, schema, input, primaryKeysTypes, fieldsToRetrieve) {
+export async function insertOne (db, sql, table, schema, input, primaryKeysTypes, fieldsToRetrieve) {
   const inputKeys = Object.keys(input)
   if (inputKeys.length === 0) {
     const insert = sql`
@@ -19,14 +17,16 @@ async function insertOne (db, sql, table, schema, input, primaryKeysTypes, field
   }
 
   const keys = sql.join(
-    inputKeys.map((key) => sql.ident(key)),
+    inputKeys.map(key => sql.ident(key)),
     sql`, `
   )
   const values = sql.join(
-    Object.keys(input).map((key) => {
+    Object.keys(input).map(key => {
       const val = input[key]
       return sql.value(val)
-    }), sql`, `)
+    }),
+    sql`, `
+  )
 
   const insert = sql`
     INSERT INTO ${tableName(sql, table, schema)} (${keys})
@@ -37,7 +37,7 @@ async function insertOne (db, sql, table, schema, input, primaryKeysTypes, field
   return res[0]
 }
 
-async function deleteAll (db, sql, table, schema, criteria, fieldsToRetrieve) {
+export async function deleteAll (db, sql, table, schema, criteria, fieldsToRetrieve) {
   let query = sql`
       DELETE FROM ${tableName(sql, table, schema)}
     `
@@ -51,7 +51,17 @@ async function deleteAll (db, sql, table, schema, criteria, fieldsToRetrieve) {
   return res
 }
 
-async function insertMany (db, sql, table, schema, inputs, inputToFieldMap, primaryKey, fieldsToRetrieve, fields) {
+export async function insertMany (
+  db,
+  sql,
+  table,
+  schema,
+  inputs,
+  inputToFieldMap,
+  primaryKey,
+  fieldsToRetrieve,
+  fields
+) {
   const { keys, values } = insertPrep(inputs, inputToFieldMap, fields, sql)
   const insert = sql`
     insert into ${tableName(sql, table, schema)} (${keys})
@@ -63,7 +73,7 @@ async function insertMany (db, sql, table, schema, inputs, inputToFieldMap, prim
   return res
 }
 
-function insertPrep (inputs, inputToFieldMap, fields, sql) {
+export function insertPrep (inputs, inputToFieldMap, fields, sql) {
   const tableFields = Object.keys(fields)
   const inputRaws = []
 
@@ -72,7 +82,7 @@ function insertPrep (inputs, inputToFieldMap, fields, sql) {
       const field = inputToFieldMap[entityKey]
 
       if (field === undefined && fields[entityKey] === undefined) {
-        throw new errors.UnknownFieldError(entityKey)
+        throw new UnknownFieldError(entityKey)
       }
     }
 
@@ -82,12 +92,7 @@ function insertPrep (inputs, inputToFieldMap, fields, sql) {
       const inputKey = fieldMetadata.camelcase
 
       let inputValue = input[inputKey] ?? input[field]
-      if (
-        inputValue &&
-        typeof inputValue === 'object' &&
-        !fieldMetadata.isArray &&
-        !(inputValue instanceof Date)
-      ) {
+      if (inputValue && typeof inputValue === 'object' && !fieldMetadata.isArray && !(inputValue instanceof Date)) {
         // This is a JSON field
         inputValue = JSON.stringify(inputValue)
       }
@@ -101,15 +106,15 @@ function insertPrep (inputs, inputToFieldMap, fields, sql) {
     inputRaws.push(sql` (${sql.join(inputValues, sql`, `)})`)
   }
   const keys = sql.join(
-    tableFields.map((key) => sql.ident(key)),
+    tableFields.map(key => sql.ident(key)),
     sql`, `
   )
 
   return { keys, values: inputRaws }
 }
 
-async function updateMany (db, sql, table, schema, criteria, input, fieldsToRetrieve) {
-  const pairs = Object.keys(input).map((key) => {
+export async function updateMany (db, sql, table, schema, criteria, input, fieldsToRetrieve) {
+  const pairs = Object.keys(input).map(key => {
     const value = input[key]
     return sql`${sql.ident(key)} = ${value}`
   })
@@ -122,11 +127,3 @@ async function updateMany (db, sql, table, schema, criteria, input, fieldsToRetr
   const res = await db.query(update)
   return res
 }
-
-module.exports = {
-  insertOne,
-  insertPrep,
-  deleteAll,
-  insertMany,
-  updateMany,
-}

package/lib/queries/sqlite.js

@@ -1,7 +1,5 @@
-'use strict'
-
-const { randomUUID } = require('crypto')
-const errors = require('../errors')
+import { randomUUID } from 'crypto'
+import { SQLiteOnlySupportsAutoIncrementOnOneColumnError } from '../errors.js'
 
 function fixValue (value) {
   if (value instanceof Date) {
@@ -12,7 +10,7 @@ function fixValue (value) {
   return value
 }
 
-async function listTables (db, sql) {
+export async function listTables (db, sql) {
   const res = await db.query(sql`
     SELECT name FROM sqlite_master
     WHERE type='table'
@@ -21,9 +19,7 @@ async function listTables (db, sql) {
   return res.map(r => ({ schema: null, table: r.name }))
 }
 
-module.exports.listTables = listTables
-
-async function listColumns (db, sql, table) {
+export async function listColumns (db, sql, table) {
   // pragma_table_info is not returning hidden column which tells if the column is generated or not
   // therefore it is changed to pragma_table_xinfo
   const columns = await db.query(sql`
@@ -36,14 +32,12 @@ async function listColumns (db, sql, table) {
     // convert is_nullable
     column.is_nullable = column.notnull === 0 && column.pk === 0 ? 'YES' : 'NO'
     // convert hidden to is_generated
-    column.is_generated = (column.hidden === 2 || column.hidden === 3) ? 'YES' : 'NO'
+    column.is_generated = column.hidden === 2 || column.hidden === 3 ? 'YES' : 'NO'
   }
   return columns
 }
 
-module.exports.listColumns = listColumns
-
-async function listConstraints (db, sql, table) {
+export async function listConstraints (db, sql, table) {
   const constraints = []
   const pks = await db.query(sql`
     SELECT *
@@ -54,7 +48,7 @@ async function listConstraints (db, sql, table) {
   for (const pk of pks) {
     constraints.push({
       column_name: pk.name,
-      constraint_type: 'PRIMARY KEY',
+      constraint_type: 'PRIMARY KEY'
     })
   }
 
@@ -69,7 +63,7 @@ async function listConstraints (db, sql, table) {
     if (index.unique === 1) {
       constraints.push({
         column_name: index.name,
-        constraint_type: 'UNIQUE',
+        constraint_type: 'UNIQUE'
       })
     }
   }
@@ -85,15 +79,13 @@ async function listConstraints (db, sql, table) {
       column_name: foreignKey.from,
       constraint_type: 'FOREIGN KEY',
       foreign_table_name: foreignKey.table,
-      foreign_column_name: foreignKey.to,
+      foreign_column_name: foreignKey.to
     })
   }
   return constraints
 }
 
-module.exports.listConstraints = listConstraints
-
-async function insertOne (db, sql, table, schema, input, primaryKeys, fieldsToRetrieve) {
+export async function insertOne (db, sql, table, schema, input, primaryKeys, fieldsToRetrieve) {
   const primaryKeyValues = {}
 
   let hasAutoIncrementPK = false
@@ -109,7 +101,7 @@ async function insertOne (db, sql, table, schema, input, primaryKeys, fieldsToRe
         primaryKeyValue = null
         hasAutoIncrementPK = true
       } else {
-        throw new errors.SQLiteOnlySupportsAutoIncrementOnOneColumnError()
+        throw new SQLiteOnlySupportsAutoIncrementOnOneColumnError()
       }
       input[key] = primaryKeyValue
     }
@@ -170,10 +162,8 @@ async function insertOne (db, sql, table, schema, input, primaryKeys, fieldsToRe
   }
 }
 
-module.exports.insertOne = insertOne
-
-async function updateOne (db, sql, table, schema, input, primaryKeys, fieldsToRetrieve) {
-  const pairs = Object.keys(input).map((key) => {
+export 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)} = ${fixValue(value)}`
   })
@@ -199,9 +189,7 @@ async function updateOne (db, sql, table, schema, input, primaryKeys, fieldsToRe
   return res[0]
 }
 
-module.exports.updateOne = updateOne
-
-async function deleteAll (db, sql, table, schema, criteria, fieldsToRetrieve) {
+export async function deleteAll (db, sql, table, schema, criteria, fieldsToRetrieve) {
   let query = sql`
     SELECT ${sql.join(fieldsToRetrieve, sql`, `)}
     FROM ${sql.ident(table)}
@@ -228,10 +216,8 @@ async function deleteAll (db, sql, table, schema, criteria, fieldsToRetrieve) {
   return data
 }
 
-module.exports.deleteAll = deleteAll
-
-async function updateMany (db, sql, table, schema, criteria, input, fieldsToRetrieve) {
-  const pairs = Object.keys(input).map((key) => {
+export async function updateMany (db, sql, table, schema, criteria, input, fieldsToRetrieve) {
+  const pairs = Object.keys(input).map(key => {
     const value = input[key]
     return sql`${sql.ident(key)} = ${fixValue(value)}`
   })
@@ -245,6 +231,4 @@ async function updateMany (db, sql, table, schema, criteria, input, fieldsToRetr
   return res
 }
 
-module.exports.updateMany = updateMany
-
-module.exports.hasILIKE = false
+export const hasILIKE = false

package/lib/telemetry.js

@@ -1,6 +1,4 @@
-'use strict'
-
-function wrapQuery (app, db, request) {
+export function wrapQuery (app, db, request) {
   const { startSpan, endSpan, SpanKind } = app.openTelemetry
   async function wrappedQuery () {
     const query = arguments[0]
@@ -18,8 +16,8 @@ function wrapQuery (app, db, request) {
     }
 
     const format = {
-      escapeIdentifier: (str) => (str),
-      formatValue: (value, index) => ({ placeholder: `$${index + 1}`, value }),
+      escapeIdentifier: str => str,
+      formatValue: (value, index) => ({ placeholder: `$${index + 1}`, value })
     }
     const { text: queryText } = query.format(format)
     // We get the name form the first 20 characters of the query
@@ -33,7 +31,7 @@ function wrapQuery (app, db, request) {
     const telemetryAttributes = {
       'db.statement': queryText,
       'db.system': dbSystem,
-      'db.name': database,
+      'db.name': database
     }
 
     if (!db.isSQLite) {
@@ -57,12 +55,12 @@ function wrapQuery (app, db, request) {
   return wrappedQuery
 }
 
-function wrapDB (app, db, request) {
+export function wrapDB (app, db, request) {
   const newDb = Object.create(db)
   const connectionInfo = db.connectionInfo
   newDb.query = wrapQuery(app, db, request)
   newDb.tx = function wrappedTx (func) {
-    return db.tx((db) => {
+    return db.tx(db => {
       db.connectionInfo = connectionInfo
       const _newDb = Object.create(db)
       _newDb.query = wrapQuery(app, db, request)
@@ -72,7 +70,7 @@ function wrapDB (app, db, request) {
   return newDb
 }
 
-const setupTelemetry = app => {
+export function setupTelemetry (app) {
   // Decorate the request with the wrapped DB.
   // We need that for the queries written directly using `db`
   if (app.platformatic.db) {
@@ -81,8 +79,3 @@ const setupTelemetry = app => {
     })
   }
 }
-
-module.exports = {
-  setupTelemetry,
-  wrapDB,
-}

package/lib/utils.js

@@ -1,20 +1,18 @@
-'use strict'
+import camelcase from 'camelcase'
+import { singularize } from 'inflected'
+import { ParamLimitMustBeNotNegativeError, ParamLimitNotAllowedError } from './errors.js'
 
-const { singularize } = require('inflected')
-const camelcase = require('camelcase')
-const errors = require('./errors')
-
-function toUpperFirst (str) {
+export function toUpperFirst (str) {
   str = str.toString()
   return str[0].toUpperCase() + str.slice(1)
 }
 
-function toLowerFirst (str) {
+export function toLowerFirst (str) {
   str = str.toString()
   return str.charAt(0).toLowerCase() + str.slice(1)
 }
 
-function toSingular (str) {
+export function toSingular (str) {
   str = camelcase(singularize(str))
   str = toUpperFirst(str)
   return str
@@ -24,36 +22,27 @@ function toSingular (str) {
  * If limit is not defined or invalid
  * let's set a safe default value preventing to load huge amount of data in memory
  */
-function sanitizeLimit (unsafeLimit, conf) {
+export function sanitizeLimit (unsafeLimit, conf) {
   const defaultLimit = conf?.default ?? 10
-  const limit = (unsafeLimit !== undefined) ? unsafeLimit : defaultLimit
+  const limit = unsafeLimit !== undefined ? unsafeLimit : defaultLimit
   const max = conf?.max ?? 100
 
   if (limit > max) {
-    throw new errors.ParamLimitNotAllowedError(limit, max)
+    throw new ParamLimitNotAllowedError(limit, max)
   }
 
   if (limit < 0) {
-    throw new errors.ParamLimitMustBeNotNegativeError(limit)
+    throw new ParamLimitMustBeNotNegativeError(limit)
   }
 
   return limit
 }
 
-function tableName (sql, table, schema) {
+export function tableName (sql, table, schema) {
   /* istanbul ignore next */
   return schema ? sql.ident(schema, table) : sql.ident(table)
 }
 
-function areSchemasSupported (sql) {
+export function areSchemasSupported (sql) {
   return !sql.isSQLite
 }
-
-module.exports = {
-  toSingular,
-  toUpperFirst,
-  toLowerFirst,
-  sanitizeLimit,
-  tableName,
-  areSchemasSupported,
-}