@platformatic/sql-mapper 0.40.0 → 0.41.0

package/lib/entity.js

@@ -223,6 +223,9 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
       }
       const value = where[key]
       const field = inputToFieldMap[key]
+      if (!field) {
+        throw new Error(`Unknown field ${key}`)
+      }
       for (const key of Object.keys(value)) {
         const operator = whereMap[key]
         /* istanbul ignore next */
@@ -231,7 +234,6 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
           throw new Error(`Unsupported where clause ${JSON.stringify(where[key])}`)
         }
         const fieldWrap = fields[field]
-
         /* istanbul ignore next */
         if (fieldWrap.isArray) {
           if (operator === 'ANY') {

package/mapper.d.ts

@@ -277,19 +277,38 @@ export interface EntityHooks<EntityFields = any> {
   count?: EntityHook<Count>,
 }
 
-export interface SQLMapperPluginOptions {
+interface BasePoolOptions {
   /**
    * Database connection string.
    */
   connectionString: string,
+
   /**
-   * Set to true to enable auto timestamping for updated_at and inserted_at fields.
+   * The maximum number of connections to create at once. Default is 10.
+   * @default 10
    */
-  autoTimestamp?: boolean,
+  poolSize?: number
+}
+
+export interface CreateConnectionPoolOptions extends BasePoolOptions {
+  /**
+   * A logger object (like [Pino](https://getpino.io))
+   */
+  log: ILogger
+}
+
+export function createConnectionPool(options: CreateConnectionPoolOptions) : Promise<{ db: Database, sql: SQL }>
+
+export interface SQLMapperPluginOptions extends BasePoolOptions {
   /**
    * A logger object (like [Pino](https://getpino.io))
    */
   log?: ILogger,
+
+  /**
+   * Set to true to enable auto timestamping for updated_at and inserted_at fields.
+   */
+  autoTimestamp?: boolean,
   /**
    * Database table to ignore when mapping to entities.
    */

package/mapper.js

@@ -47,25 +47,17 @@ const defaultAutoTimestampFields = {
   updatedAt: 'updated_at'
 }
 
-async function connect ({ connectionString, log, onDatabaseLoad, poolSize = 10, ignore = {}, autoTimestamp = true, hooks = {}, schema, limit = {}, dbschema }) {
-  if (typeof autoTimestamp === 'boolean' && autoTimestamp === true) {
-    autoTimestamp = defaultAutoTimestampFields
-  }
-  // TODO validate config using the schema
-  if (!connectionString) {
-    throw new Error('connectionString is required')
-  }
-
-  let queries
-  let sql
+async function createConnectionPool ({ log, connectionString, poolSize }) {
   let db
+  let sql
+
+  poolSize = poolSize || 10
 
   /* istanbul ignore next */
   if (connectionString.indexOf('postgres') === 0) {
     const createConnectionPoolPg = require('@databases/pg')
     db = await buildConnection(log, createConnectionPoolPg, connectionString, poolSize)
     sql = createConnectionPoolPg.sql
-    queries = queriesFactory.pg
     db.isPg = true
   } else if (connectionString.indexOf('mysql') === 0) {
     const createConnectionPoolMysql = require('@databases/mysql')
@@ -74,11 +66,8 @@ async function connect ({ connectionString, log, onDatabaseLoad, poolSize = 10,
     const version = (await db.query(sql`SELECT VERSION()`))[0]['VERSION()']
     db.version = version
     db.isMariaDB = version.indexOf('maria') !== -1
-    if (db.isMariaDB) {
-      queries = queriesFactory.mariadb
-    } else {
+    if (!db.isMariaDB) {
       db.isMySql = true
-      queries = queriesFactory.mysql
     }
   } else if (connectionString.indexOf('sqlite') === 0) {
     const sqlite = require('@matteo.collina/sqlite-pool')
@@ -98,12 +87,37 @@ async function connect ({ connectionString, log, onDatabaseLoad, poolSize = 10,
       }
     })
     sql = sqlite.sql
-    queries = queriesFactory.sqlite
     db.isSQLite = true
   } else {
     throw new Error('You must specify either postgres, mysql or sqlite as protocols')
   }
 
+  return { db, sql }
+}
+
+async function connect ({ connectionString, log, onDatabaseLoad, poolSize, ignore = {}, autoTimestamp = true, hooks = {}, schema, limit = {}, dbschema }) {
+  if (typeof autoTimestamp === 'boolean' && autoTimestamp === true) {
+    autoTimestamp = defaultAutoTimestampFields
+  }
+  // TODO validate config using the schema
+  if (!connectionString) {
+    throw new Error('connectionString is required')
+  }
+
+  let queries
+  const { db, sql } = await createConnectionPool({ log, connectionString, poolSize })
+
+  /* istanbul ignore next */
+  if (db.isPg) {
+    queries = queriesFactory.pg
+  } else if (db.isMySql) {
+    queries = queriesFactory.mysql
+  } else if (db.isMariaDB) {
+    queries = queriesFactory.mariadb
+  } else if (db.isSQLite) {
+    queries = queriesFactory.sqlite
+  }
+
   // Specify an empty array must be the same of specifying no schema
   /* istanbul ignore next */ // Ignoring because this won't be fully covered by DB not supporting schemas (SQLite)
   const schemaList = areSchemasSupported(db) && schema?.length > 0 ? schema : null
@@ -222,5 +236,6 @@ async function sqlMapper (app, opts) {
 
 module.exports = fp(sqlMapper)
 module.exports.connect = connect
+module.exports.createConnectionPool = createConnectionPool
 module.exports.plugin = module.exports
 module.exports.utils = require('./lib/utils')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/sql-mapper",
-  "version": "0.40.0",
+  "version": "0.41.0",
   "description": "A data mapper utility for SQL databases",
   "main": "mapper.js",
   "types": "mapper.d.ts",
@@ -19,7 +19,7 @@
     "snazzy": "^9.0.0",
     "standard": "^17.1.0",
     "tap": "^16.3.6",
-    "tsd": "^0.28.1"
+    "tsd": "^0.29.0"
   },
   "dependencies": {
     "@databases/mysql": "^6.0.0",
@@ -30,7 +30,7 @@
     "camelcase": "^6.3.0",
     "fastify-plugin": "^4.5.0",
     "inflected": "^2.1.0",
-    "@platformatic/types": "0.40.0"
+    "@platformatic/types": "0.41.0"
   },
   "tsd": {
     "directory": "test/types"

package/test/create-connection.test.js

@@ -0,0 +1,39 @@
+'use strict'
+
+const { test } = require('tap')
+const { clear, connInfo, isSQLite } = require('./helper')
+const { createConnectionPool } = require('..')
+const fakeLogger = {
+  trace: () => {},
+  error: () => {}
+}
+
+test('createConnectionPool', async ({ equal, same, teardown, rejects }) => {
+  const { db, sql } = await createConnectionPool({
+    connectionString: connInfo.connectionString,
+    log: fakeLogger
+  })
+  await clear(db, sql)
+  teardown(() => db.dispose())
+  if (isSQLite) {
+    await db.query(sql`CREATE TABLE pages (
+        id INTEGER PRIMARY KEY,
+        the_title VARCHAR(42),
+        is_published BOOLEAN NOT NULL
+      );`)
+  } else {
+    await db.query(sql`CREATE TABLE pages (
+        id SERIAL PRIMARY KEY,
+        the_title VARCHAR(255) NOT NULL,
+        is_published BOOLEAN NOT NULL
+      );`)
+  }
+  await db.query(sql`INSERT INTO pages (the_title, is_published) VALUES ('foo', true)`)
+
+  const res = await db.query(sql`SELECT * FROM pages`)
+  same(res, [{
+    id: 1,
+    the_title: 'foo',
+    is_published: true
+  }])
+})

package/test/types/mapper.test-d.ts

@@ -10,9 +10,16 @@ import {
   Database,
   SQLMapperPluginInterface,
   EntityHooks,
+  createConnectionPool
 } from '../../mapper'
 
-const pluginOptions: SQLMapperPluginInterface = await connect({ connectionString: '' })
+const log = {
+  trace() {},
+  error() {},
+  warn() {}
+}
+
+const pluginOptions: SQLMapperPluginInterface = await connect({ connectionString: '', log })
 expectType<Database>(pluginOptions.db)
 expectType<SQL>(pluginOptions.sql)
 expectType<{ [entityName: string]: Entity }>(pluginOptions.entities)
@@ -49,17 +56,18 @@ const entityHooks: EntityHooks = {
   async count(originalCount: typeof entity.count, ...options: Parameters<typeof entity.count>): ReturnType<typeof entity.count> { return 0 },
 }
 expectType<EntityHooks>(entityHooks)
-expectType<SQLMapperPluginInterface>(await connect({ connectionString: '' }))
-expectType<SQLMapperPluginInterface>(await connect({ connectionString: '', autoTimestamp: true }))
-expectType<SQLMapperPluginInterface>(await connect({ connectionString: '', hooks: {} }))
+expectType<SQLMapperPluginInterface>(await connect({ connectionString: '', log }))
+expectType<SQLMapperPluginInterface>(await connect({ connectionString: '', autoTimestamp: true, log }))
+expectType<SQLMapperPluginInterface>(await connect({ connectionString: '', hooks: {}, log }))
 expectType<SQLMapperPluginInterface>(await connect({
   connectionString: '', hooks: {
     Page: entityHooks
-  }
+  },
+  log
 }))
-expectType<SQLMapperPluginInterface>(await connect({ connectionString: '', ignore: {} }))
+expectType<SQLMapperPluginInterface>(await connect({ connectionString: '', ignore: {}, log }))
 expectType<SQLMapperPluginInterface>(await connect({
-  connectionString: '', onDatabaseLoad(db: Database, sql: SQL) {
+  connectionString: '', log, onDatabaseLoad(db: Database, sql: SQL) {
     expectType<(query: SQLQuery) => Promise<any[]>>(db.query)
     expectType<() => Promise<void>>(db.dispose)
     expectType<boolean | undefined>(pluginOptions.db.isMySql)
@@ -95,3 +103,5 @@ instance.register((instance) => {
 })
 
 expectType<(str: string) => string>(utils.toSingular)
+
+expectType<Promise<{ db: Database, sql: SQL }>>(createConnectionPool({ connectionString: '', log }))

package/test/updateMany.test.js

@@ -4,6 +4,7 @@ const { test } = require('tap')
 const { connect } = require('..')
 const { clear, connInfo, isSQLite, isMysql } = require('./helper')
 const { setTimeout } = require('timers/promises')
+
 const fakeLogger = {
   trace: () => {},
   error: () => {}

package/test/where.test.js

@@ -3,12 +3,13 @@
 const { test } = require('tap')
 const { connect } = require('..')
 const { clear, connInfo, isMysql, isSQLite } = require('./helper')
+
 const fakeLogger = {
   trace: () => {},
   error: () => {}
 }
 
-test('list', async ({ pass, teardown, same, equal }) => {
+test('list', async ({ pass, teardown, same, rejects }) => {
   const mapper = await connect({
     ...connInfo,
     log: fakeLogger,
@@ -60,6 +61,8 @@ test('list', async ({ pass, teardown, same, equal }) => {
     inputs: posts
   })
 
+  rejects(entity.find.bind(entity, { where: { invalidField: { eq: 'Dog' } } }), 'Unknown field invalidField')
+
   same(await entity.find({ where: { title: { eq: 'Dog' } }, fields: ['id', 'title', 'longText'] }), [{
     id: '1',
     title: 'Dog',