@platformatic/sql-mapper 0.43.1 → 0.45.0

package/lib/entity.js

@@ -8,6 +8,7 @@ const {
   sanitizeLimit
 } = require('./utils')
 const { singularize } = require('inflected')
+const errors = require('./errors')
 
 function lowerCaseFirst (str) {
   str = str.toString()
@@ -49,7 +50,7 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
         if (fields[key] !== undefined) {
           newKey = key
         } else {
-          throw new Error(`Unknown field ${key}`)
+          throw new errors.UnknownFieldError(key)
         }
       }
       newInput[newKey] = value
@@ -76,7 +77,7 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
   async function save (args) {
     const db = args.tx || defaultDb
     if (args.input === undefined) {
-      throw new Error('Input not provided.')
+      throw new errors.InputNotProvidedError()
     }
     // args.input is not array
     const fieldsToRetrieve = computeFields(args.fields).map((f) => sql.ident(f))
@@ -154,7 +155,7 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
     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.')
+      throw new errors.InputNotProvidedError()
     }
     const input = fixInput(args.input)
     if (autoTimestamp && fields[autoTimestamp.updatedAt]) {
@@ -224,14 +225,14 @@ 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}`)
+        throw new errors.UnknownFieldError(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])}`)
+          throw new errors.UnsupportedWhereClauseError(JSON.stringify(where[key]))
         }
         const fieldWrap = fields[field]
         /* istanbul ignore next */
@@ -247,7 +248,7 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
           } else if (operator === '&&') {
             criteria.push(sql`${sql.ident(field)} && ${value[key]}`)
           } else {
-            throw new Error('Unsupported operator for Array field')
+            throw new errors.UnsupportedOperatorForArrayFieldError()
           }
         } else if (operator === '=' && value[key] === null) {
           criteria.push(sql`${sql.ident(field)} IS NULL`)
@@ -263,7 +264,7 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
           const like = operator === 'LIKE' ? sql`LIKE` : queries.hasILIKE ? sql`ILIKE` : sql`LIKE`
           criteria.push(sql`${leftHand} ${like} ${value[key]}`)
         } else if (operator === 'ANY' || operator === 'ALL' || operator === '@>' || operator === '<@' || operator === '&&') {
-          throw new Error('Unsupported operator for non Array field')
+          throw new errors.UnsupportedOperatorForNonArrayFieldError()
         } else {
           criteria.push(sql`${sql.ident(field)} ${sql.__dangerous__rawValue(operator)} ${computeCriteriaValue(fieldWrap, value[key])}`)
         }
@@ -314,7 +315,7 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
     query = sql`${query} LIMIT ${sanitizeLimit(opts.limit, limitConfig)}`
     if (opts.offset !== undefined) {
       if (opts.offset < 0) {
-        throw new Error(`Param offset=${opts.offset} not allowed. It must be not negative value.`)
+        throw new errors.ParamNotAllowedError(opts.offset)
       }
       query = sql`${query} OFFSET ${opts.offset}`
     }
@@ -416,7 +417,7 @@ function buildEntity (db, sql, log, table, queries, autoTimestamp, schema, useSc
       const validTypes = ['varchar', 'integer', 'uuid', 'serial']
       const pkType = fields[constraint.column_name].sqlType.toLowerCase()
       if (!validTypes.includes(pkType)) {
-        throw new Error(`Invalid Primary Key type: "${pkType}". We support the following: ${validTypes.join(', ')}.`)
+        throw new errors.InvalidPrimaryKeyTypeError(pkType, validTypes.join(', '))
       }
     }
   }

package/lib/errors.js

@@ -0,0 +1,23 @@
+'use strict'
+
+const createError = require('@fastify/error')
+
+const ERROR_PREFIX = 'PLT_SQL_MAPPER'
+
+module.exports = {
+  CannotFindEntityError: createError(`${ERROR_PREFIX}_CANNOT_FIND_ENTITY`, 'Cannot find entity %s'),
+  SpecifyProtocolError: createError(`${ERROR_PREFIX}_SPECIFY_PROTOCOLS`, 'You must specify either postgres, mysql or sqlite as protocols'),
+  ConnectionStringRequiredError: createError(`${ERROR_PREFIX}_CONNECTION_STRING_REQUIRED`, 'connectionString is required'),
+  TableMustBeAStringError: createError(`${ERROR_PREFIX}_TABLE_MUST_BE_A_STRING`, 'Table must be a string, got %s'),
+  UnknownFieldError: createError(`${ERROR_PREFIX}_UNKNOWN_FIELD`, 'Unknown field %s'),
+  InputNotProvidedError: createError(`${ERROR_PREFIX}_INPUT_NOT_PROVIDED`, 'Input not provided.'),
+  UnsupportedWhereClauseError: createError(`${ERROR_PREFIX}_UNSUPPORTED_WHERE_CLAUSE`, 'Unsupported where clause %s'),
+  UnsupportedOperatorForArrayFieldError: createError(`${ERROR_PREFIX}_UNSUPPORTED_OPERATOR`, 'Unsupported operator for Array field'),
+  UnsupportedOperatorForNonArrayFieldError: createError(`${ERROR_PREFIX}_UNSUPPORTED_OPERATOR_FOR_NON_ARRAY`, 'Unsupported operator for non Array field'),
+  ParamNotAllowedError: createError(`${ERROR_PREFIX}_PARAM_NOT_ALLOWED`, 'Param offset=%s not allowed. It must be not negative value.'),
+  InvalidPrimaryKeyTypeError: createError(`${ERROR_PREFIX}_INVALID_PRIMARY_KEY_TYPE`, 'Invalid Primary Key type: "%s". We support the following: %s'),
+  ParamLimitNotAllowedError: createError(`${ERROR_PREFIX}_PARAM_LIMIT_NOT_ALLOWED`, 'Param limit=%s not allowed. Max accepted value %s.'),
+  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'),
+  SQLiteOnlySupportsAutoIncrementOnOneColumnError: createError(`${ERROR_PREFIX}_SQLITE_ONLY_SUPPORTS_AUTO_INCREMENT_ON_ONE_COLUMN`, 'SQLite only supports autoIncrement on one column')
+}

package/lib/queries/mysql.js

@@ -3,6 +3,7 @@
 const { insertPrep } = require('./shared')
 const shared = require('./mysql-shared')
 const { tableName } = require('../utils')
+const errors = require('../errors')
 
 function insertOne (db, sql, table, schema, input, primaryKeys, fieldsToRetrieve) {
   const keysToSql = Object.keys(input).map((key) => sql.ident(key))
@@ -48,7 +49,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 Error(`Missing value for primary key ${key}`)
+        throw new errors.MissingValueForPrimaryKeyError(key)
       }
       where.push(sql`${sql.ident(key)} = ${input[key]}`)
     }

package/lib/queries/shared.js

@@ -1,6 +1,7 @@
 'use strict'
 
 const { tableName } = require('../utils')
+const errors = require('../errors')
 
 /* istanbul ignore file */
 
@@ -71,7 +72,7 @@ function insertPrep (inputs, inputToFieldMap, fields, sql) {
       let newKey = key
       if (inputToFieldMap[key] === undefined) {
         if (fields[key] === undefined) {
-          throw new Error('Unknown field ' + key)
+          throw new errors.UnknownFieldError(key)
         }
       } else {
         newKey = inputToFieldMap[key]

package/lib/queries/sqlite.js

@@ -1,6 +1,7 @@
 'use strict'
 
 const { randomUUID } = require('crypto')
+const errors = require('../errors')
 
 function fixValue (value) {
   if (value instanceof Date) {
@@ -108,7 +109,7 @@ async function insertOne (db, sql, table, schema, input, primaryKeys, fieldsToRe
         primaryKeyValue = null
         hasAutoIncrementPK = true
       } else {
-        throw new Error('SQLite only supports autoIncrement on one column')
+        throw new errors.SQLiteOnlySupportsAutoIncrementOnOneColumnError()
       }
       input[key] = primaryKeyValue
     }

package/lib/utils.js

@@ -2,6 +2,7 @@
 
 const { singularize } = require('inflected')
 const camelcase = require('camelcase')
+const errors = require('./errors')
 
 function toUpperFirst (str) {
   return str[0].toUpperCase() + str.slice(1)
@@ -23,11 +24,11 @@ function sanitizeLimit (unsafeLimit, conf) {
   const max = conf?.max ?? 100
 
   if (limit > max) {
-    throw new Error(`Param limit=${limit} not allowed. Max accepted value ${max}.`)
+    throw new errors.ParamLimitNotAllowedError(limit, max)
   }
 
   if (limit < 0) {
-    throw new Error(`Param limit=${limit} not allowed. It must be not negative value.`)
+    throw new errors.ParamLimitMustBeNotNegativeError(limit)
   }
 
   return limit

package/mapper.d.ts

@@ -1,6 +1,6 @@
 import { FastifyPluginAsync, FastifyInstance, FastifyReply, FastifyRequest } from 'fastify'
-import type { PlatformaticApp } from '@platformatic/types'
 import { SQL, SQLQuery } from '@databases/sql'
+import { FastifyError } from '@fastify/error'
 
 interface ILogger {
   trace(): any,
@@ -297,7 +297,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 {
   /**
@@ -333,7 +333,7 @@ export interface Entities {
   [entityName: string]: Entity
 }
 
-export interface SQLMapperPluginInterface {
+export interface SQLMapperPluginInterface<T extends Entities> {
   /**
    * A Database abstraction layer from [@Databases](https://www.atdatabases.org/)
    */
@@ -345,7 +345,7 @@ export interface SQLMapperPluginInterface {
   /**
    * An object containing a key for each table found in the schema, with basic CRUD operations. See [entity.md](./entity.md) for details.
    */
-  entities: Entities,
+  entities: T,
   /**
    * Adds hooks to the entity.
    */
@@ -357,33 +357,6 @@ export interface SQLMapperPluginInterface {
   cleanUpAllEntities(): Promise<void>
 }
 
-// Extend the PlatformaticApp interface,
-// Unfortunately we neeed to copy over all the types from SQLMapperPluginInterface
-declare module '@platformatic/types' {
-  interface PlatformaticApp {
-    /**
-     * A Database abstraction layer from [@Databases](https://www.atdatabases.org/)
-     */
-    db: Database,
-    /**
-     * The SQL builder from [@Databases](https://www.atdatabases.org/)
-     */
-    sql: SQL,
-    /**
-     * An object containing a key for each table found in the schema, with basic CRUD operations. See [entity.md](./entity.md) for details.
-     */
-    entities: Entities,
-    /**
-     * Adds hooks to the entity.
-     */
-    addEntityHooks<EntityFields>(entityName: string, hooks: EntityHooks<EntityFields>): any
-    /**
-     * Clean up all the data in all entities
-     */
-    cleanUpAllEntities(): Promise<void>
-  }
-}
-
 export interface PlatformaticContext {
   app: FastifyInstance,
   reply: FastifyReply
@@ -398,7 +371,7 @@ declare module 'fastify' {
 /**
  * Connects to the database and maps the tables to entities.
  */
-export function connect(options: SQLMapperPluginOptions): Promise<SQLMapperPluginInterface>
+export function connect<T extends Entities>(options: SQLMapperPluginOptions): Promise<SQLMapperPluginInterface<T>>
 /**
  * Fastify plugin that connects to the database and maps the tables to entities.
  */
@@ -412,3 +385,25 @@ export module utils {
   export function toSingular(str: string): string
 }
 
+/**
+ * All the errors thrown by the plugin.
+ */
+export module errors {
+  export const CannotFindEntityError: (entityName: string) => FastifyError
+  export const SpecifyProtocolError: () => FastifyError
+  export const ConnectionStringRequiredError: () => FastifyError
+  export const TableMustBeAStringError: (table: any) => FastifyError
+  export const UnknownFieldError: (key: string) => FastifyError
+  export const InputNotProvidedError: () => FastifyError
+  export const UnsupportedWhereClauseError: (where: string) => FastifyError
+  export const UnsupportedOperatorForArrayFieldError: () => FastifyError
+  export const UnsupportedOperatorForNonArrayFieldError: () => FastifyError
+  export const ParamNotAllowedError: (offset: string) => FastifyError
+  export const InvalidPrimaryKeyTypeError: (pkType: string, validTypes: string) => FastifyError
+  export const ParamLimitNotAllowedError: (limit: string, max: string) => FastifyError
+  export const ParamLimitMustBeNotNegativeError: (limit: string) => FastifyError
+  export const MissingValueForPrimaryKeyError: (key: string) => FastifyError
+  export const SQLiteOnlySupportsAutoIncrementOnOneColumnError: () => FastifyError
+}
+
+

package/mapper.js

@@ -5,6 +5,7 @@ const buildCleanUp = require('./lib/clean-up')
 const queriesFactory = require('./lib/queries')
 const fp = require('fastify-plugin')
 const { areSchemasSupported } = require('./lib/utils')
+const errors = require('./lib/errors')
 
 // Ignore the function as it is only used only for MySQL and PostgreSQL
 /* istanbul ignore next */
@@ -89,7 +90,7 @@ async function createConnectionPool ({ log, connectionString, poolSize }) {
     sql = sqlite.sql
     db.isSQLite = true
   } else {
-    throw new Error('You must specify either postgres, mysql or sqlite as protocols')
+    throw new errors.SpecifyProtocolError()
   }
 
   return { db, sql }
@@ -101,7 +102,7 @@ async function connect ({ connectionString, log, onDatabaseLoad, poolSize, ignor
   }
   // TODO validate config using the schema
   if (!connectionString) {
-    throw new Error('connectionString is required')
+    throw new errors.ConnectionStringRequiredError()
   }
 
   let queries
@@ -162,7 +163,7 @@ async function connect ({ connectionString, log, onDatabaseLoad, poolSize, ignor
       // it should never happen.
       /* istanbul ignore next */
       if (typeof table !== 'string') {
-        throw new Error(`Table must be a string, got '${table}'`)
+        throw new errors.TableMustBeAStringError(table)
       }
       if (ignore[table] === true) {
         continue
@@ -199,7 +200,7 @@ async function connect ({ connectionString, log, onDatabaseLoad, poolSize, ignor
   function addEntityHooks (entityName, hooks) {
     const entity = entities[entityName]
     if (!entity) {
-      throw new Error('Cannot find entity ' + entityName)
+      throw new errors.CannotFindEntityError(entityName)
     }
     for (const key of Object.keys(hooks)) {
       if (hooks[key] && entity[key]) {
@@ -239,3 +240,4 @@ module.exports.connect = connect
 module.exports.createConnectionPool = createConnectionPool
 module.exports.plugin = module.exports
 module.exports.utils = require('./lib/utils')
+module.exports.errors = errors

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/sql-mapper",
-  "version": "0.43.1",
+  "version": "0.45.0",
   "description": "A data mapper utility for SQL databases",
   "main": "mapper.js",
   "types": "mapper.d.ts",
@@ -25,12 +25,12 @@
     "@databases/mysql": "^6.0.0",
     "@databases/pg": "^5.4.1",
     "@databases/sql": "^3.3.0",
+    "@fastify/error": "^3.2.1",
     "@hapi/topo": "^6.0.2",
     "@matteo.collina/sqlite-pool": "^0.3.0",
     "camelcase": "^6.3.0",
     "fastify-plugin": "^4.5.0",
-    "inflected": "^2.1.0",
-    "@platformatic/types": "0.43.1"
+    "inflected": "^2.1.0"
   },
   "tsd": {
     "directory": "test/types"

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

@@ -1,6 +1,7 @@
 import { expectType } from 'tsd'
 import { SQL, SQLQuery } from '@databases/sql'
 import { fastify, FastifyInstance, FastifyReply } from 'fastify'
+import { FastifyError } from '@fastify/error'
 import {
   connect,
   plugin,
@@ -10,16 +11,24 @@ import {
   Database,
   SQLMapperPluginInterface,
   EntityHooks,
-  createConnectionPool
+  createConnectionPool,
+  Entities,
+  errors
 } from '../../mapper'
 
 const log = {
-  trace() {},
-  error() {},
-  warn() {}
+  trace() { },
+  error() { },
+  warn() { }
 }
 
-const pluginOptions: SQLMapperPluginInterface = await connect({ connectionString: '', log })
+declare module 'fastify' {
+  interface FastifyInstance {
+    platformatic: SQLMapperPluginInterface<Entities>
+  }
+}
+
+const pluginOptions: SQLMapperPluginInterface<Entities> = await connect<Entities>({ connectionString: '', log })
 expectType<Database>(pluginOptions.db)
 expectType<SQL>(pluginOptions.sql)
 expectType<{ [entityName: string]: Entity }>(pluginOptions.entities)
@@ -56,17 +65,17 @@ 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: '', log }))
-expectType<SQLMapperPluginInterface>(await connect({ connectionString: '', autoTimestamp: true, log }))
-expectType<SQLMapperPluginInterface>(await connect({ connectionString: '', hooks: {}, log }))
-expectType<SQLMapperPluginInterface>(await connect({
+expectType<SQLMapperPluginInterface<Entities>>(await connect<Entities>({ connectionString: '', log }))
+expectType<SQLMapperPluginInterface<Entities>>(await connect<Entities>({ connectionString: '', autoTimestamp: true, log }))
+expectType<SQLMapperPluginInterface<Entities>>(await connect<Entities>({ connectionString: '', hooks: {}, log }))
+expectType<SQLMapperPluginInterface<Entities>>(await connect<Entities>({
   connectionString: '', hooks: {
     Page: entityHooks
   },
   log
 }))
-expectType<SQLMapperPluginInterface>(await connect({ connectionString: '', ignore: {}, log }))
-expectType<SQLMapperPluginInterface>(await connect({
+expectType<SQLMapperPluginInterface<Entities>>(await connect<Entities>({ connectionString: '', ignore: {}, log }))
+expectType<SQLMapperPluginInterface<Entities>>(await connect<Entities>({
   connectionString: '', log, onDatabaseLoad(db: Database, sql: SQL) {
     expectType<(query: SQLQuery) => Promise<any[]>>(db.query)
     expectType<() => Promise<void>>(db.dispose)
@@ -81,10 +90,10 @@ expectType<SQLMapperPluginInterface>(await connect({
 const instance: FastifyInstance = fastify()
 instance.register(plugin, { connectionString: '', autoTimestamp: true })
 instance.register((instance) => { 
-  expectType<SQLMapperPluginInterface>(instance.platformatic)
+  expectType<SQLMapperPluginInterface<Entities>>(instance.platformatic)
 
   instance.platformatic.addEntityHooks<EntityFields>('something', {
-    async find (originalFind, options) {
+    async find(originalFind, options) {
       expectType<Partial<EntityFields>[]>(await originalFind())
       expectType<Parameters<typeof entity.find>[0]>(options)
 
@@ -105,3 +114,26 @@ instance.register((instance) => {
 expectType<(str: string) => string>(utils.toSingular)
 
 expectType<Promise<{ db: Database, sql: SQL }>>(createConnectionPool({ connectionString: '', log }))
+
+// Errors
+type ErrorWithNoParams = () => FastifyError
+type ErrorWithOneParam = (param: string) => FastifyError
+type ErrorWithOneAnyParam = (param: any) => FastifyError
+type ErrorWithTwoParams = (param1: string, param2: string) => FastifyError
+
+expectType<ErrorWithOneParam>(errors.CannotFindEntityError)
+expectType<ErrorWithNoParams>(errors.SpecifyProtocolError)
+expectType<ErrorWithNoParams>(errors.ConnectionStringRequiredError)
+expectType<ErrorWithOneAnyParam>(errors.TableMustBeAStringError)
+expectType<ErrorWithOneParam>(errors.UnknownFieldError)
+expectType<ErrorWithNoParams>(errors.InputNotProvidedError)
+expectType<ErrorWithOneParam>(errors.UnsupportedWhereClauseError)
+expectType<ErrorWithNoParams>(errors.UnsupportedOperatorForArrayFieldError)
+expectType<ErrorWithNoParams>(errors.UnsupportedOperatorForNonArrayFieldError)
+expectType<ErrorWithOneParam>(errors.ParamNotAllowedError)
+expectType<ErrorWithTwoParams>(errors.InvalidPrimaryKeyTypeError)
+expectType<ErrorWithTwoParams>(errors.ParamLimitNotAllowedError)
+expectType<ErrorWithOneParam>(errors.ParamLimitMustBeNotNegativeError)
+expectType<ErrorWithOneParam>(errors.MissingValueForPrimaryKeyError)
+expectType<ErrorWithNoParams>(errors.SQLiteOnlySupportsAutoIncrementOnOneColumnError)
+

package/test/where.test.js

@@ -452,7 +452,8 @@ test('limit should be 10 by default 100 at max', async ({ pass, teardown, same,
     await entity.find({ limit: -1 })
     fail('Expected error for limit not allowed value')
   } catch (e) {
-    match(e, new Error('Param limit=-1 not allowed. It must be not negative value.'))
+    match(e.message, 'Param limit=-1 not allowed. It must be a not negative value.')
+    match(e.code, 'PLT_SQL_MAPPER_PARAM_LIMIT_MUST_BE_NOT_NEGATIVE')
   }
 
   same(await (await entity.find({ limit: 1, offset: 0 })).length, 1)
@@ -535,7 +536,8 @@ test('limit must accept custom configuration', async ({ pass, teardown, same, fa
     await entity.find({ limit: -1 })
     fail('Expected error for limit not allowed value')
   } catch (e) {
-    match(e, new Error('Param limit=-1 not allowed. It must be not negative value.'))
+    match(e.message, 'Param limit=-1 not allowed. It must be a not negative value.')
+    match(e.code, 'PLT_SQL_MAPPER_PARAM_LIMIT_MUST_BE_NOT_NEGATIVE')
   }
 
   same(await (await entity.find({ limit: 1, offset: 0 })).length, 1)