@platformatic/sql-mapper 2.0.0-alpha.2 → 2.0.0-alpha.21

package/eslint.config.js

@@ -0,0 +1,3 @@
+'use strict'
+
+module.exports = require('neostandard')({ ts: true })

package/lib/cache.js

@@ -21,10 +21,10 @@ function setupCache (res, opts) {
       serialize (query) {
         const serialized = {
           ...query,
-          ctx: undefined
+          ctx: undefined,
         }
         return serialized
-      }
+      },
     }, async function (query) {
       const res = await originalFn.call(entity, query)
       return res
@@ -36,7 +36,7 @@ function setupCache (res, opts) {
           return originalFn(query)
         }
         return cache[fnName](query)
-      }
+      },
     })
   }
 

package/lib/connection-info.js

@@ -0,0 +1,42 @@
+// The most general way to get the connection info is through the driver.
+// In this way, we don't need to do any assumptions about the connection string
+// (with the exception of SQLite)
+const getConnectionInfo = async (db, connectionString) => {
+  let database, host, port, user
+  let dbSystem = 'unknown'
+  if (db.isPg) {
+    const driver = await db._pool.getConnection()
+    const connectionParameters = driver.connection.client.connectionParameters
+    host = connectionParameters.host
+    port = connectionParameters.port
+    database = connectionParameters.database
+    user = connectionParameters.user
+    dbSystem = 'postgresql'
+    driver.release()
+  } else if (db.isMySql || db.isMariaDB || db.isMySql8) {
+    const driver = await db._pool.getConnection()
+    const connectionParameters = driver.connection.client.config
+    database = connectionParameters.database
+    host = connectionParameters.host
+    port = connectionParameters.port
+    user = connectionParameters.user
+    dbSystem = 'mysql'
+    driver.release()
+  } else if (db.isSQLite) {
+    dbSystem = 'sqlite'
+    database = connectionString?.split('sqlite://')[1]
+  }
+
+  return {
+    database,
+    host,
+    port,
+    user,
+    isPg: !!db.isPg,
+    isMySql: !!db.isMySql,
+    isSQLite: !!db.isSQLite,
+    dbSystem,
+  }
+}
+
+module.exports = { getConnectionInfo }

package/lib/entity.js

@@ -6,11 +6,12 @@ const {
   toUpperFirst,
   toLowerFirst,
   tableName,
-  sanitizeLimit
+  sanitizeLimit,
 } = require('./utils')
 const { singularize } = require('inflected')
 const { findNearestString } = require('@platformatic/utils')
 const errors = require('./errors')
+const { wrapDB } = require('./telemetry')
 
 function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relations, queries, autoTimestamp, schema, useSchemaInName, limitConfig, columns, constraintsList) {
   /* istanbul ignore next */ // Ignoring because this won't be fully covered by DB not supporting schemas (SQLite)
@@ -19,6 +20,17 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
   const pluralName = camelcase(useSchemaInName ? camelcase(`${schema} ${table}`) : table)
   const singularName = camelcase(entityName)
 
+  // If the db is in the opts, uses it, otherwise uses the defaultDb
+  // if telemetry is enabled, wraps the db with telemetry
+  const getDB = (opts) => {
+    let db = opts?.tx || defaultDb
+    if (opts?.ctx?.app?.openTelemetry && opts?.ctx?.reply?.request) {
+      const req = opts.ctx.reply.request
+      db = wrapDB(opts.ctx.app, db, req)
+    }
+    return db
+  }
+
   // Fields remapping
   const fieldMapToRetrieve = {}
   const inputToFieldMap = {}
@@ -34,7 +46,7 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
   const primaryKeysTypes = Array.from(primaryKeys).map((key) => {
     return {
       key,
-      sqlType: fields[key].sqlType
+      sqlType: fields[key].sqlType,
     }
   })
 
@@ -72,7 +84,7 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
   }
 
   async function save (args) {
-    const db = args.tx || defaultDb
+    const db = getDB(args)
     if (args.input === undefined) {
       throw new errors.InputNotProvidedError()
     }
@@ -114,7 +126,7 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
   }
 
   async function insert (args) {
-    const db = args.tx || defaultDb
+    const db = getDB(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
@@ -155,7 +167,7 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
     if (args.where === undefined || Object.keys(args.where).length === 0) {
       throw new errors.MissingWhereClauseError()
     }
-    const db = args.tx || defaultDb
+    const db = getDB(args)
     const fieldsToRetrieve = computeFields(args.fields).map((f) => sql.ident(f))
     const input = fixInput(args.input)
     if (autoTimestamp && fields[autoTimestamp.updatedAt]) {
@@ -206,7 +218,7 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
     all: 'ALL',
     contains: '@>',
     contained: '<@',
-    overlaps: '&&'
+    overlaps: '&&',
   }
 
   function computeCriteria (opts) {
@@ -291,7 +303,7 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
   }
 
   async function find (opts = {}) {
-    const db = opts.tx || defaultDb
+    const db = getDB(opts)
     const fieldsToRetrieve = computeFields(opts.fields).map((f) => sql.ident(f))
     const criteria = computeCriteria(opts)
 
@@ -326,7 +338,7 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
   }
 
   async function count (opts = {}) {
-    const db = opts.tx || defaultDb
+    const db = getDB(opts)
     let totalCountQuery = null
     totalCountQuery = sql`
         SELECT COUNT(*) AS total 
@@ -341,7 +353,7 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
   }
 
   async function _delete (opts) {
-    const db = opts.tx || defaultDb
+    const db = getDB(opts)
     const fieldsToRetrieve = computeFields(opts.fields).map((f) => sql.ident(f))
     const criteria = computeCriteria(opts)
     const res = await queries.deleteAll(db, sql, table, schema, criteria, fieldsToRetrieve)
@@ -364,7 +376,7 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
     insert,
     save,
     delete: _delete,
-    updateMany
+    updateMany,
   }
 }
 
@@ -383,7 +395,7 @@ function buildEntity (db, sql, log, table, queries, autoTimestamp, schema, useSc
     acc[column.column_name] = {
       sqlType: column.udt_name,
       isNullable: column.is_nullable === 'YES',
-      isArray: column.isArray
+      isArray: column.isArray,
     }
 
     // To get enum values in mysql and mariadb
@@ -437,7 +449,7 @@ function buildEntity (db, sql, log, table, queries, autoTimestamp, schema, useSc
     if (!field) {
       // This should never happen
       log.warn({
-        constraint
+        constraint,
       }, `No field for ${constraint.column_name}`)
       continue
     }

package/lib/errors.js

@@ -20,5 +20,5 @@ module.exports = {
   ParamLimitMustBeNotNegativeError: createError(`${ERROR_PREFIX}_PARAM_LIMIT_MUST_BE_NOT_NEGATIVE`, 'Param limit=%s not allowed. It must be a not negative value.'),
   MissingValueForPrimaryKeyError: createError(`${ERROR_PREFIX}_MISSING_VALUE_FOR_PRIMARY_KEY`, 'Missing value for primary key %s'),
   MissingWhereClauseError: createError(`${ERROR_PREFIX}_MISSING_WHERE_CLAUSE`, 'Missing where clause', 400),
-  SQLiteOnlySupportsAutoIncrementOnOneColumnError: createError(`${ERROR_PREFIX}_SQLITE_ONLY_SUPPORTS_AUTO_INCREMENT_ON_ONE_COLUMN`, 'SQLite only supports autoIncrement on one column')
+  SQLiteOnlySupportsAutoIncrementOnOneColumnError: createError(`${ERROR_PREFIX}_SQLITE_ONLY_SUPPORTS_AUTO_INCREMENT_ON_ONE_COLUMN`, 'SQLite only supports autoIncrement on one column'),
 }

package/lib/queries/index.js

@@ -5,19 +5,19 @@
 const obj = {}
 
 Object.defineProperty(obj, 'pg', {
-  get: () => require('./pg')
+  get: () => require('./pg'),
 })
 
 Object.defineProperty(obj, 'mysql', {
-  get: () => require('./mysql')
+  get: () => require('./mysql'),
 })
 
 Object.defineProperty(obj, 'mariadb', {
-  get: () => require('./mariadb')
+  get: () => require('./mariadb'),
 })
 
 Object.defineProperty(obj, 'sqlite', {
-  get: () => require('./sqlite')
+  get: () => require('./sqlite'),
 })
 
 module.exports = obj

package/lib/queries/mariadb.js

@@ -7,5 +7,5 @@ module.exports = {
   ...mysql,
   insertOne: shared.insertOne,
   insertMany: shared.insertMany,
-  deleteAll: shared.deleteAll
+  deleteAll: shared.deleteAll,
 }

package/lib/queries/mysql-shared.js

@@ -113,7 +113,7 @@ module.exports = {
   listColumns,
   listConstraints,
   updateOne,
-  updateMany
+  updateMany,
 }
 
 module.exports.hasILIKE = false

package/lib/queries/mysql.js

@@ -149,5 +149,5 @@ module.exports = {
   ...shared,
   insertOne,
   insertMany,
-  deleteAll
+  deleteAll,
 }

package/lib/queries/shared.js

@@ -128,5 +128,5 @@ module.exports = {
   insertPrep,
   deleteAll,
   insertMany,
-  updateMany
+  updateMany,
 }

package/lib/queries/sqlite.js

@@ -54,7 +54,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 +69,7 @@ async function listConstraints (db, sql, table) {
     if (index.unique === 1) {
       constraints.push({
         column_name: index.name,
-        constraint_type: 'UNIQUE'
+        constraint_type: 'UNIQUE',
       })
     }
   }
@@ -85,7 +85,7 @@ 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

package/lib/telemetry.js

@@ -0,0 +1,88 @@
+'use strict'
+
+function wrapQuery (app, db, request) {
+  const { startSpan, endSpan, SpanKind } = app.openTelemetry
+  async function wrappedQuery () {
+    const query = arguments[0]
+    const connectionInfo = db.connectionInfo
+
+    let namePrefix
+    if (connectionInfo.isPg) {
+      namePrefix = 'pg.query:'
+    } else if (connectionInfo.isMySql) {
+      namePrefix = 'mysql.query:'
+    } else if (connectionInfo.isSQLite) {
+      namePrefix = 'sqlite.query:'
+    } else {
+      namePrefix = 'db.query:'
+    }
+
+    const format = {
+      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
+    // The spane name is not really important, all the info (included the full query) are in the attributes)
+    const name = queryText.substring(0, 20)
+    const spanName = `${namePrefix}${name.replace(/\n|\r/g, ' ')}`
+
+    const ctx = request.span?.context
+
+    const { database, host, port, user, dbSystem } = connectionInfo
+    const telemetryAttributes = {
+      'db.statement': queryText,
+      'db.system': dbSystem,
+      'db.name': database,
+    }
+
+    if (!db.isSQLite) {
+      // we dont' set the connection string as property because it can contain the password
+      telemetryAttributes['db.user'] = user
+      telemetryAttributes['net.peer.name'] = host
+      telemetryAttributes['net.peer.port'] = port
+    }
+
+    let span
+    try {
+      span = startSpan(spanName, ctx, telemetryAttributes, SpanKind.CLIENT)
+      const result = await db.query.apply(db, arguments)
+      endSpan(span)
+      return result
+    } catch (err) /* istanbul ignore next */ {
+      endSpan(span, err)
+      throw err
+    }
+  }
+  return wrappedQuery
+}
+
+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) => {
+      db.connectionInfo = connectionInfo
+      const _newDb = Object.create(db)
+      _newDb.query = wrapQuery(app, db, request)
+      return func(_newDb)
+    })
+  }
+  return newDb
+}
+
+const setupTelemetry = app => {
+  // Decorate the request with the wrapped DB.
+  // We need that for the queries written directly using `db`
+  if (app.platformatic.db) {
+    app.decorateRequest('getDB', function getDB () {
+      return wrapDB(app, app.platformatic.db, this)
+    })
+  }
+}
+
+module.exports = {
+  setupTelemetry,
+  wrapDB,
+}

package/lib/utils.js

@@ -55,5 +55,5 @@ module.exports = {
   toLowerFirst,
   sanitizeLimit,
   tableName,
-  areSchemasSupported
+  areSchemasSupported,
 }

package/mapper.d.ts

@@ -1,7 +1,7 @@
-import { FastifyPluginAsync, FastifyInstance, FastifyReply, FastifyRequest } from 'fastify'
+import { FastifyPluginAsync, FastifyInstance, FastifyReply } from 'fastify'
 import { SQL, SQLQuery } from '@databases/sql'
 import { FastifyError } from '@fastify/error'
-import { createCache } from 'async-cache-dedupe'
+import type { createCache } from 'async-cache-dedupe'
 
 type cacheOptions = (Parameters<typeof createCache>[0]) | boolean
 
@@ -74,11 +74,11 @@ export interface WhereCondition {
     /**
      * Equal to value.
      */
-    eq?: string | null,
+    eq?: string | number | boolean | null,
     /**
      * Not equal to value.
      */
-    neq?: string | null,
+    neq?: string | number | boolean | null,
     /**
      * Greater than value.
      */
@@ -315,7 +315,7 @@ export interface Entity<EntityFields = any> {
   updateMany: UpdateMany<EntityFields>
 }
 
-type EntityHook<T extends (...args: any) => any> = (original: T, ...options: Parameters<T>) => ReturnType<T>;
+type EntityHook<T extends (...args: any) => any> = (original: T, ...options: Parameters<T>) => ReturnType<T>
 
 export interface EntityHooks<EntityFields = any> {
   find?: EntityHook<Find<EntityFields>>,
@@ -367,7 +367,7 @@ export interface CreateConnectionPoolOptions extends BasePoolOptions {
   log: ILogger
 }
 
-export function createConnectionPool(options: CreateConnectionPoolOptions): Promise<{ db: Database, sql: SQL }>
+export function createConnectionPool (options: CreateConnectionPoolOptions): Promise<{ db: Database, sql: SQL }>
 
 export interface SQLMapperPluginOptions extends BasePoolOptions {
   /**
@@ -446,7 +446,7 @@ declare module 'fastify' {
 /**
  * Connects to the database and maps the tables to entities.
  */
-export function connect<T extends Entities>(options: SQLMapperPluginOptions): Promise<SQLMapperPluginInterface<T>>
+export function connect<T extends Entities> (options: SQLMapperPluginOptions): Promise<SQLMapperPluginInterface<T>>
 /**
  * Fastify plugin that connects to the database and maps the tables to entities.
  */
@@ -457,7 +457,7 @@ export default plugin
  * An object that contains utility functions.
  */
 export module utils {
-  export function toSingular(str: string): string
+  export function toSingular (str: string): string
 }
 
 /**
@@ -480,5 +480,3 @@ export module errors {
   export const MissingValueForPrimaryKeyError: (key: string) => FastifyError
   export const SQLiteOnlySupportsAutoIncrementOnOneColumnError: () => FastifyError
 }
-
-

package/mapper.js

@@ -8,6 +8,8 @@ const queriesFactory = require('./lib/queries')
 const { areSchemasSupported } = require('./lib/utils')
 const errors = require('./lib/errors')
 const setupCache = require('./lib/cache')
+const { setupTelemetry } = require('./lib/telemetry')
+const { getConnectionInfo } = require('./lib/connection-info')
 
 // Ignore the function as it is only used only for MySQL and PostgreSQL
 /* istanbul ignore next */
@@ -23,34 +25,34 @@ async function buildConnection (log, createConnectionPool, connectionString, poo
       log.trace({
         query: {
           text,
-          values
-        }
+          values,
+        },
       }, 'start query')
     },
     onQueryResults: (_query, { text }, results) => {
       log.trace({
         query: {
           text,
-          results: results.length
-        }
+          results: results.length,
+        },
       }, 'end query')
     },
     onQueryError: (_query, { text }, err) => {
       log.error({
         query: {
           text,
-          error: err.message
-        }
+          error: err.message,
+        },
       }, 'query error')
     },
-    schema
+    schema,
   })
   return db
 }
 
 const defaultAutoTimestampFields = {
   createdAt: 'created_at',
-  updatedAt: 'updated_at'
+  updatedAt: 'updated_at',
 }
 
 async function createConnectionPool ({ log, connectionString, poolSize, idleTimeoutMilliseconds, queueTimeoutMilliseconds, acquireLockTimeoutMilliseconds }) {
@@ -87,17 +89,22 @@ async function createConnectionPool ({ log, connectionString, poolSize, idleTime
       onQuery ({ text, values }) {
         log.trace({
           query: {
-            text
-          }
+            text,
+          },
         }, 'query')
-      }
+      },
     })
     sql = sqlite.sql
     db.isSQLite = true
+    db.sql = sql
   } else {
     throw new errors.SpecifyProtocolError()
   }
 
+  // These info are necessary for telemetry attributes
+  const connectionInfo = await getConnectionInfo(db, connectionString)
+  db.connectionInfo = connectionInfo
+
   return { db, sql }
 }
 
@@ -224,7 +231,7 @@ async function connect ({ connectionString, log, onDatabaseLoad, poolSize, inclu
       entities,
       cleanUpAllEntities: buildCleanUp(db, sql, log, entities, queries),
       addEntityHooks,
-      dbschema
+      dbschema,
     }
 
     if (cache) {
@@ -253,7 +260,7 @@ async function connect ({ connectionString, log, onDatabaseLoad, poolSize, inclu
 async function sqlMapper (app, opts) {
   const mapper = await connect({
     log: app.log,
-    ...opts
+    ...opts,
   })
 
   app.onClose(() => mapper.db.dispose())
@@ -269,10 +276,15 @@ async function sqlMapper (app, opts) {
   app.addHook('onRequest', function (req, reply, done) {
     req.platformaticContext = {
       app: this, // uses the encapsulated fastify instance of the route
-      reply
+      reply,
     }
     done()
   })
+
+  // TODO: should we enable db telemetry explicitely with a config?
+  if (app.openTelemetry) {
+    setupTelemetry(app)
+  }
 }
 
 async function dropTable (db, sql, table) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/sql-mapper",
-  "version": "2.0.0-alpha.2",
+  "version": "2.0.0-alpha.21",
   "description": "A data mapper utility for SQL databases",
   "main": "mapper.js",
   "types": "mapper.d.ts",
@@ -16,32 +16,35 @@
   "homepage": "https://github.com/platformatic/platformatic#readme",
   "devDependencies": {
     "@matteo.collina/tspl": "^0.1.1",
-    "borp": "^0.16.0",
-    "fastify": "^4.26.2",
-    "snazzy": "^9.0.0",
-    "standard": "^17.1.0",
-    "tsd": "^0.31.0"
+    "@opentelemetry/api": "^1.8.0",
+    "borp": "^0.17.0",
+    "eslint": "9",
+    "fastify": "^5.0.0",
+    "neostandard": "^0.11.1",
+    "tsd": "^0.31.0",
+    "typescript": "^5.5.4"
   },
   "dependencies": {
     "@databases/mysql": "^6.0.0",
     "@databases/pg": "^5.5.0",
     "@databases/sql": "^3.3.0",
-    "@fastify/error": "^3.4.1",
+    "@fastify/error": "^4.0.0",
     "@hapi/topo": "^6.0.2",
     "@matteo.collina/sqlite-pool": "^0.4.0",
     "async-cache-dedupe": "^2.1.0",
     "camelcase": "^6.3.0",
-    "fastify-plugin": "^4.5.1",
+    "fastify-plugin": "^5.0.0",
     "inflected": "^2.1.0",
-    "@platformatic/utils": "2.0.0-alpha.2"
+    "@platformatic/telemetry": "2.0.0-alpha.21",
+    "@platformatic/utils": "2.0.0-alpha.21"
   },
   "tsd": {
     "directory": "test/types"
   },
   "scripts": {
-    "lint": "standard | snazzy",
+    "lint": "eslint",
     "test": "npm run lint && npm run test:typescript && npm run test:postgresql && npm run test:mariadb && npm run test:mysql && npm run test:mysql8 && npm run test:sqlite",
-    "test:runner": "borp --pattern 'test/**/*.test.{js, mjs}' --concurrency=1 --timeout=60000",
+    "test:runner": "borp --pattern 'test/**/*.test.{js, mjs}' --concurrency=1 --timeout=180000",
     "test:postgresql": "DB=postgresql npm run test:runner",
     "test:mariadb": "DB=mariadb npm run test:runner",
     "test:mysql": "DB=mysql npm run test:runner",