@platformatic/sql-mapper 0.8.0 → 0.9.1

package/lib/entity.js

@@ -1,14 +1,19 @@
 'use strict'
 
 const camelcase = require('camelcase')
-const { singularize } = require('inflected')
 const {
   toSingular,
-  tableName
+  toUpperFirst,
+  tableName,
+  sanitizeLimit
 } = require('./utils')
 
-function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relations, queries, autoTimestamp, schema) {
-  const entityName = toSingular(table)
+function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relations, queries, autoTimestamp, schema, useSchemaInName, limitConfig) {
+  /* istanbul ignore next */ // Ignoring because this won't be fully covered by DB not supporting schemas (SQLite)
+  const entityName = useSchemaInName ? toUpperFirst(`${schema}${toSingular(table)}`) : toSingular(table)
+  /* istanbul ignore next */
+  const pluralName = camelcase(useSchemaInName ? camelcase(`${schema} ${table}`) : table)
+  const singularName = camelcase(entityName)
 
   // Fields remapping
   const fieldMapToRetrieve = {}
@@ -265,13 +270,12 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
       query = sql`${query} ORDER BY ${sql.join(orderBy, sql`, `)}`
     }
 
-    if (opts.limit || opts.offset !== undefined) {
-      // Use Number.MAX_SAFE_INTEGER as default value for limit because in the sql query you cannot add OFFSET without LIMIT
-      const limit = (opts.limit !== undefined) ? opts.limit : Number.MAX_SAFE_INTEGER
-      query = sql`${query} LIMIT ${limit}`
-      if (opts.offset !== undefined) {
-        query = sql`${query} OFFSET ${opts.offset}`
+    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.`)
       }
+      query = sql`${query} OFFSET ${opts.offset}`
     }
 
     const res = await db.query(query)
@@ -303,8 +307,8 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
 
   return {
     name: entityName,
-    singularName: camelcase(singularize(table)),
-    pluralName: camelcase(table),
+    singularName,
+    pluralName,
     primaryKeys,
     table,
     schema,
@@ -321,7 +325,7 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
   }
 }
 
-async function buildEntity (db, sql, log, table, queries, autoTimestamp, schema, ignore) {
+async function buildEntity (db, sql, log, table, queries, autoTimestamp, schema, useSchemaInName, ignore, limitConfig) {
   // Compute the columns
   const columns = (await queries.listColumns(db, sql, table, schema)).filter((c) => !ignore[c.column_name])
   const fields = columns.reduce((acc, column) => {
@@ -391,7 +395,7 @@ async function buildEntity (db, sql, log, table, queries, autoTimestamp, schema,
     }
   }
 
-  const entity = createMapper(db, sql, log, table, fields, primaryKeys, currentRelations, queries, autoTimestamp, schema)
+  const entity = createMapper(db, sql, log, table, fields, primaryKeys, currentRelations, queries, autoTimestamp, schema, useSchemaInName, limitConfig)
   entity.relations = currentRelations
 
   return entity

package/lib/queries/pg.js

@@ -14,7 +14,6 @@ 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)
 }
 

package/lib/utils.js

@@ -3,18 +3,49 @@
 const { singularize } = require('inflected')
 const camelcase = require('camelcase')
 
+function toUpperFirst (str) {
+  return str[0].toUpperCase() + str.slice(1)
+}
+
 function toSingular (str) {
   str = camelcase(singularize(str))
-  str = str[0].toUpperCase() + str.slice(1)
+  str = toUpperFirst(str)
   return 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) {
+  const defaultLimit = conf?.default ?? 10
+  const limit = (unsafeLimit !== undefined) ? unsafeLimit : defaultLimit
+  const max = conf?.max ?? 100
+
+  if (limit > max) {
+    throw new Error(`Param limit=${limit} not allowed. Max accepted value ${max}.`)
+  }
+
+  if (limit < 0) {
+    throw new Error(`Param limit=${limit} not allowed. It must be not negative value.`)
+  }
+
+  return limit
+}
+
 function tableName (sql, table, schema) {
   /* istanbul ignore next */
   return schema ? sql.ident(schema, table) : sql.ident(table)
 }
 
+function areSchemasSupported (sql) {
+  return !sql.isSQLite
+}
+
 module.exports = {
   toSingular,
-  tableName
+  toUpperFirst,
+  sanitizeLimit,
+  tableName,
+  areSchemasSupported
 }

package/mapper.js

@@ -1,8 +1,7 @@
-'use strict'
-
 const buildEntity = require('./lib/entity')
 const queriesFactory = require('./lib/queries')
 const fp = require('fastify-plugin')
+const { areSchemasSupported } = require('./lib/utils')
 
 // Ignore the function as it is only used only for MySQL and PostgreSQL
 /* istanbul ignore next */
@@ -40,7 +39,7 @@ async function buildConnection (log, createConnectionPool, connectionString, poo
   return db
 }
 
-async function connect ({ connectionString, log, onDatabaseLoad, poolSize = 10, ignore = {}, autoTimestamp = true, hooks = {}, schema }) {
+async function connect ({ connectionString, log, onDatabaseLoad, poolSize = 10, ignore = {}, autoTimestamp = true, hooks = {}, schema, limit = {} }) {
   // TODO validate config using the schema
   if (!connectionString) {
     throw new Error('connectionString is required')
@@ -50,15 +49,10 @@ async function connect ({ connectionString, log, onDatabaseLoad, poolSize = 10,
   let sql
   let db
 
-  // Specify an empty array must be the same of specifying no schema
-  const schemaList = schema?.length > 0 ? schema : null
-
   /* istanbul ignore next */
   if (connectionString.indexOf('postgres') === 0) {
     const createConnectionPoolPg = require('@databases/pg')
-    // We pass schema here so @databases/pg set the schema in the search path. This is not stritly necessary, though,
-    // because now we use fully qualified names in all queries.
-    db = await buildConnection(log, createConnectionPoolPg, connectionString, poolSize, schemaList)
+    db = await buildConnection(log, createConnectionPoolPg, connectionString, poolSize)
     sql = createConnectionPoolPg.sql
     queries = queriesFactory.pg
     db.isPg = true
@@ -93,6 +87,11 @@ async function connect ({ connectionString, log, onDatabaseLoad, poolSize = 10,
     throw new Error('You must specify either postgres, mysql or sqlite as protocols')
   }
 
+  // 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
+  const useSchema = !!schemaList
+
   const entities = {}
 
   try {
@@ -102,14 +101,6 @@ async function connect ({ connectionString, log, onDatabaseLoad, poolSize = 10,
     }
 
     const tablesWithSchema = await queries.listTables(db, sql, schemaList)
-    const tables = tablesWithSchema.map(({ table }) => table)
-    const duplicates = tables.filter((table, index) => tables.indexOf(table) !== index)
-
-    // Ignored because this never happens in sqlite
-    /* istanbul ignore next */
-    if (duplicates.length > 0) {
-      throw new Error(`Conflicting table names: ${duplicates.join(', ')}`)
-    }
 
     for (const { table, schema } of tablesWithSchema) {
       // The following line is a safety net when developing this module,
@@ -121,12 +112,14 @@ async function connect ({ connectionString, log, onDatabaseLoad, poolSize = 10,
       if (ignore[table] === true) {
         continue
       }
-      const entity = await buildEntity(db, sql, log, table, queries, autoTimestamp, schema, ignore[table] || {})
+      const entity = await buildEntity(db, sql, log, table, queries, autoTimestamp, schema, useSchema, ignore[table] || {}, limit)
       // Check for primary key of all entities
       if (entity.primaryKeys.size === 0) {
-        throw new Error(`Cannot find any primary keys for ${entity.name} entity`)
+        throw Error(`Cannot find any primary keys for ${entity.name} entity`)
       }
+
       entities[entity.singularName] = entity
+
       if (hooks[entity.name]) {
         addEntityHooks(entity.singularName, hooks[entity.name])
       } else if (hooks[entity.singularName]) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/sql-mapper",
-  "version": "0.8.0",
+  "version": "0.9.1",
   "description": "A data mapper utility for SQL databases",
   "main": "mapper.js",
   "repository": {
@@ -18,7 +18,7 @@
     "snazzy": "^9.0.0",
     "standard": "^17.0.0",
     "tap": "^16.0.0",
-    "tsd": "^0.24.0"
+    "tsd": "^0.25.0"
   },
   "dependencies": {
     "@databases/mysql": "^5.2.0",

package/test/schema.test.js

@@ -48,15 +48,15 @@ test('uses tables from different schemas', { skip: isSQLite }, async ({ pass, te
     hooks: {},
     schema: ['test1', 'test2']
   })
-  const pageEntity = mapper.entities.page
-  equal(pageEntity.name, 'Page')
-  equal(pageEntity.singularName, 'page')
-  equal(pageEntity.pluralName, 'pages')
+  const pageEntity = mapper.entities.test1Page
+  equal(pageEntity.name, 'Test1Page')
+  equal(pageEntity.singularName, 'test1Page')
+  equal(pageEntity.pluralName, 'test1Pages')
   equal(pageEntity.schema, 'test1')
-  const userEntity = mapper.entities.user
-  equal(userEntity.name, 'User')
-  equal(userEntity.singularName, 'user')
-  equal(userEntity.pluralName, 'users')
+  const userEntity = mapper.entities.test2User
+  equal(userEntity.name, 'Test2User')
+  equal(userEntity.singularName, 'test2User')
+  equal(userEntity.pluralName, 'test2Users')
   equal(userEntity.schema, 'test2')
   pass()
 })
@@ -98,61 +98,13 @@ test('find enums correctly using schemas', { skip: isSQLite }, async ({ pass, te
     hooks: {},
     schema: ['test1']
   })
-  const pageEntity = mapper.entities.page
-  equal(pageEntity.name, 'Page')
-  equal(pageEntity.singularName, 'page')
-  equal(pageEntity.pluralName, 'pages')
+  const pageEntity = mapper.entities.test1Page
+  equal(pageEntity.name, 'Test1Page')
+  equal(pageEntity.singularName, 'test1Page')
+  equal(pageEntity.pluralName, 'test1Pages')
   pass()
 })
 
-test('should fail if two schemas has the same table', { skip: isSQLite }, async ({ pass, teardown, equal }) => {
-  async function onDatabaseLoad (db, sql) {
-    await clear(db, sql)
-    teardown(() => db.dispose())
-
-    await db.query(sql`CREATE SCHEMA IF NOT EXISTS test1;`)
-    if (isMysql || isMysql8) {
-      await db.query(sql`CREATE TABLE IF NOT EXISTS \`test1\`.\`pages\` (
-      id SERIAL PRIMARY KEY,
-      title VARCHAR(255) NOT NULL
-    );`)
-    } else {
-      await db.query(sql`CREATE TABLE IF NOT EXISTS "test1"."pages" (
-      id SERIAL PRIMARY KEY,
-      title VARCHAR(255) NOT NULL
-    );`)
-    }
-
-    await db.query(sql`CREATE SCHEMA IF NOT EXISTS test2;`)
-
-    if (isMysql || isMysql8) {
-      await db.query(sql`CREATE TABLE IF NOT EXISTS \`test2\`.\`pages\` (
-      id SERIAL PRIMARY KEY,
-      username VARCHAR(255) NOT NULL
-    );`)
-    } else {
-      await db.query(sql`CREATE TABLE IF NOT EXISTS "test2"."pages" (
-      id SERIAL PRIMARY KEY,
-      username VARCHAR(255) NOT NULL
-    );`)
-    }
-  }
-
-  try {
-    await connect({
-      connectionString: connInfo.connectionString,
-      log: fakeLogger,
-      onDatabaseLoad,
-      ignore: {},
-      hooks: {},
-      schema: ['test1', 'test2']
-    })
-  } catch (err) {
-    console.log(err.message)
-    equal(err.message, 'Conflicting table names: pages')
-  }
-})
-
 test('if schema is empty array, should not load entities from tables in explicit schema', { skip: isSQLite }, async ({ pass, teardown, equal }) => {
   async function onDatabaseLoad (db, sql) {
     await clear(db, sql)
@@ -194,7 +146,6 @@ test('if schema is empty array, should not load entities from tables in explicit
     schema: []
   })
 
-  console.log(mapper.entities)
   equal(Object.keys(mapper.entities).length, 0)
   pass()
 })
@@ -259,3 +210,111 @@ test('[sqlite] if sqllite, ignores schema information', { skip: !isSQLite }, asy
   equal(pageEntity.schema, null)
   pass()
 })
+
+test('addEntityHooks in entities with schema', { skip: isSQLite }, async ({ pass, teardown, same, equal, plan, fail, throws, end }) => {
+  async function onDatabaseLoad (db, sql) {
+    await clear(db, sql)
+    teardown(() => db.dispose())
+
+    await db.query(sql`CREATE SCHEMA IF NOT EXISTS test1;`)
+    if (isMysql || isMysql8) {
+      await db.query(sql`CREATE TABLE IF NOT EXISTS \`test1\`.\`pages\` (
+      id SERIAL PRIMARY KEY,
+      title VARCHAR(255) NOT NULL
+    );`)
+    } else {
+      await db.query(sql`CREATE TABLE IF NOT EXISTS "test1"."pages" (
+      id SERIAL PRIMARY KEY,
+      title VARCHAR(255) NOT NULL
+    );`)
+    }
+  }
+
+  const mapper = await connect({
+    ...connInfo,
+    log: fakeLogger,
+    onDatabaseLoad,
+    schema: ['test1']
+  })
+
+  throws(() => mapper.addEntityHooks('user', {}), 'Cannot find entity user')
+
+  mapper.addEntityHooks('test1Page', {
+    noKey () {
+      fail('noKey should never be called')
+    },
+    async save (original, { input, ctx, fields }) {
+      pass('save  called')
+
+      if (!input.id) {
+        same(input, {
+          title: 'Hello'
+        })
+
+        return original({
+          input: {
+            title: 'Hello from hook'
+          },
+          fields
+        })
+      } else {
+        same(input, {
+          id: 1,
+          title: 'Hello World'
+        })
+
+        return original({
+          input: {
+            id: 1,
+            title: 'Hello from hook 2'
+          },
+          fields
+        })
+      }
+    },
+    async find (original, args) {
+      pass('find called')
+
+      same(args.where, {
+        id: {
+          eq: '1'
+        }
+      })
+      args.where = {
+        id: {
+          eq: '2'
+        }
+      }
+      same(args.fields, ['id', 'title'])
+      return original(args)
+    },
+    async insert (original, args) {
+      pass('insert called')
+
+      same(args.inputs, [{
+        title: 'hello'
+      }, {
+        title: 'world'
+      }])
+      same(args.fields, ['id', 'title'])
+      return original(args)
+    }
+  })
+
+  const entity = mapper.entities.test1Page
+
+  same(await entity.save({ input: { title: 'Hello' } }), {
+    id: 1,
+    title: 'Hello from hook'
+  })
+
+  same(await entity.find({ where: { id: { eq: 1 } }, fields: ['id', 'title'] }), [])
+
+  same(await entity.save({ input: { id: 1, title: 'Hello World' } }), {
+    id: 1,
+    title: 'Hello from hook 2'
+  })
+
+  await entity.insert({ inputs: [{ title: 'hello' }, { title: 'world' }], fields: ['id', 'title'] })
+  end()
+})

package/test/where.test.js

@@ -388,6 +388,170 @@ test('foreign keys', async ({ pass, teardown, same, equal }) => {
   }
 })
 
+test('limit should be 10 by default 100 at max', async ({ pass, teardown, same, fail, match }) => {
+  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 = []
+
+  for (let i = 0; i <= 105; i++) {
+    posts.push({
+      title: 'Dog',
+      longText: 'Foo',
+      counter: i
+    })
+  }
+
+  await entity.insert({
+    inputs: posts
+  })
+
+  const defaultLimit = 10
+  const max = 100
+
+  same(await (await entity.find()).length, defaultLimit)
+
+  same(await (await entity.find({ limit: 1 })).length, 1)
+
+  same(await (await entity.find({ offset: 3 })).length, defaultLimit)
+
+  same(await (await entity.find({ limit: 1, offset: 0 })).length, 1)
+
+  same(await (await entity.find({ limit: 0 })).length, 0)
+
+  try {
+    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.'))
+  }
+
+  same(await (await entity.find({ limit: 1, offset: 0 })).length, 1)
+
+  try {
+    await entity.find({ limit: 1, offset: -1 })
+    fail('Expected error for offset not allowed value')
+  } catch (e) {
+    match(e, new Error('Param offset=-1 not allowed. It must be not negative value.'))
+  }
+
+  try {
+    await entity.find({ limit: 200 })
+    fail('Expected error for limit exceeding max allowed value')
+  } catch (e) {
+    match(e, new Error(`Param limit=200 not allowed. Max accepted value ${max}.`))
+  }
+})
+
+test('limit must accept custom configuration', async ({ pass, teardown, same, fail, match }) => {
+  const customLimitConf = {
+    default: 1,
+    max: 5
+  }
+  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
+        );`)
+      }
+    },
+    limit: customLimitConf
+  })
+
+  const entity = mapper.entities.post
+
+  const posts = []
+
+  for (let i = 0; i <= 10; i++) {
+    posts.push({
+      title: 'Dog',
+      longText: 'Foo',
+      counter: i
+    })
+  }
+
+  await entity.insert({
+    inputs: posts
+  })
+
+  same(await (await entity.find()).length, customLimitConf.default)
+
+  same(await (await entity.find({ limit: 1 })).length, 1)
+
+  same(await (await entity.find({ offset: 3 })).length, customLimitConf.default)
+
+  same(await (await entity.find({ limit: 1, offset: 0 })).length, 1)
+
+  same(await (await entity.find({ limit: 0 })).length, 0)
+
+  try {
+    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.'))
+  }
+
+  same(await (await entity.find({ limit: 1, offset: 0 })).length, 1)
+
+  try {
+    await entity.find({ limit: 1, offset: -1 })
+    fail('Expected error for offset not allowed value')
+  } catch (e) {
+    match(e, new Error('Param offset=-1 not allowed. It must be not negative value.'))
+  }
+
+  try {
+    await entity.find({ limit: 200 })
+    fail('Expected error for limit exceeding max allowed value')
+  } catch (e) {
+    match(e, new Error(`Param limit=200 not allowed. Max accepted value ${customLimitConf.max}.`))
+  }
+})
+
 test('is NULL', async ({ pass, teardown, same, equal }) => {
   const mapper = await connect({
     ...connInfo,