@platformatic/sql-mapper 0.45.0 → 0.46.1

package/lib/entity.js

@@ -8,6 +8,7 @@ const {
   sanitizeLimit
 } = require('./utils')
 const { singularize } = require('inflected')
+const { findNearestString } = require('@platformatic/utils')
 const errors = require('./errors')
 
 function lowerCaseFirst (str) {
@@ -369,6 +370,14 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
 }
 
 function buildEntity (db, sql, log, table, queries, autoTimestamp, schema, useSchemaInName, ignore, limitConfig, schemaList, columns, constraintsList) {
+  const columnsNames = columns.map(c => c.column_name)
+  for (const ignoredColumn of Object.keys(ignore)) {
+    if (!columnsNames.includes(ignoredColumn)) {
+      const nearestColumn = findNearestString(columnsNames, ignoredColumn)
+      log.warn(`Ignored column "${ignoredColumn}" not found. Did you mean "${nearestColumn}"?`)
+    }
+  }
+
   // Compute the columns
   columns = columns.filter((c) => !ignore[c.column_name])
   const fields = columns.reduce((acc, column) => {

package/mapper.js

@@ -1,5 +1,6 @@
 'use strict'
 
+const { findNearestString } = require('@platformatic/utils')
 const buildEntity = require('./lib/entity')
 const buildCleanUp = require('./lib/clean-up')
 const queriesFactory = require('./lib/queries')
@@ -158,6 +159,18 @@ async function connect ({ connectionString, log, onDatabaseLoad, poolSize, ignor
       }
     }
 
+    const schemaTables = dbschema.map(table => table.table)
+    for (const ignoredTable of Object.keys(ignore)) {
+      if (!schemaTables.includes(ignoredTable)) {
+        const nearestTable = findNearestString(schemaTables, ignoredTable)
+        let warningMessage = `Ignored table "${ignoredTable}" not found.`
+        if (nearestTable) {
+          warningMessage += ` Did you mean "${nearestTable}"?`
+        }
+        log.warn(warningMessage)
+      }
+    }
+
     for (const { table, schema, columns, constraints } of dbschema) {
       // The following line is a safety net when developing this module,
       // it should never happen.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/sql-mapper",
-  "version": "0.45.0",
+  "version": "0.46.1",
   "description": "A data mapper utility for SQL databases",
   "main": "mapper.js",
   "types": "mapper.d.ts",
@@ -30,7 +30,8 @@
     "@matteo.collina/sqlite-pool": "^0.3.0",
     "camelcase": "^6.3.0",
     "fastify-plugin": "^4.5.0",
-    "inflected": "^2.1.0"
+    "inflected": "^2.1.0",
+    "@platformatic/utils": "0.46.1"
   },
   "tsd": {
     "directory": "test/types"

package/test/ignore.test.js

@@ -0,0 +1,187 @@
+'use strict'
+
+const { test } = require('tap')
+const { connect } = require('..')
+const { clear, connInfo, isSQLite } = require('./helper')
+
+const fakeLogger = {
+  trace: () => {},
+  error: () => {},
+  warn: () => {}
+}
+
+async function createBasicPages (db, sql) {
+  if (isSQLite) {
+    await db.query(sql`CREATE TABLE pages (
+      id INTEGER PRIMARY KEY,
+      title VARCHAR(42)
+    );`)
+    await db.query(sql`CREATE TABLE categories (
+      id INTEGER PRIMARY KEY,
+      name VARCHAR(42)
+    );`)
+  } else {
+    await db.query(sql`CREATE TABLE pages (
+      id SERIAL PRIMARY KEY,
+      title VARCHAR(42)
+    );`)
+    await db.query(sql`CREATE TABLE categories (
+      id SERIAL PRIMARY KEY,
+      name VARCHAR(42)
+    );`)
+  }
+}
+
+test('ignore a table', async ({ pass, teardown, equal }) => {
+  async function onDatabaseLoad (db, sql) {
+    pass('onDatabaseLoad called')
+    teardown(() => db.dispose())
+
+    await clear(db, sql)
+    await createBasicPages(db, sql)
+  }
+
+  const mapper = await connect({
+    ...connInfo,
+    log: fakeLogger,
+    onDatabaseLoad,
+    ignore: {
+      categories: true
+    }
+  })
+
+  const pageEntity = mapper.entities.page
+  equal(pageEntity.name, 'Page')
+
+  const categoryEntity = mapper.entities.category
+  equal(categoryEntity, undefined, 'category entity is ignored')
+})
+
+test('show a warning if there is no ignored table', async ({ plan, pass, teardown, equal }) => {
+  plan(4)
+
+  async function onDatabaseLoad (db, sql) {
+    pass('onDatabaseLoad called')
+    teardown(() => db.dispose())
+
+    await clear(db, sql)
+    await createBasicPages(db, sql)
+  }
+
+  const logger = {
+    trace: () => {},
+    error: () => {},
+    warn: (msg) => {
+      equal(msg, 'Ignored table "missing_table_pages" not found. Did you mean "pages"?')
+    }
+  }
+
+  const mapper = await connect({
+    ...connInfo,
+    log: logger,
+    onDatabaseLoad,
+    ignore: {
+      missing_table_pages: true
+    }
+  })
+
+  const pageEntity = mapper.entities.page
+  equal(pageEntity.name, 'Page')
+
+  const categoryEntity = mapper.entities.category
+  equal(categoryEntity.name, 'Category')
+})
+
+test('show a warning if the database is empty', async ({ plan, pass, teardown, equal }) => {
+  // plan(4)
+
+  async function onDatabaseLoad (db, sql) {
+    pass('onDatabaseLoad called')
+    teardown(() => db.dispose())
+
+    await clear(db, sql)
+  }
+
+  const logger = {
+    trace: () => {},
+    error: () => {},
+    warn: (msg) => {
+      equal(msg, 'Ignored table "missing_table_pages" not found.')
+    }
+  }
+
+  await connect({
+    ...connInfo,
+    log: logger,
+    onDatabaseLoad,
+    ignore: {
+      missing_table_pages: true
+    }
+  })
+})
+
+test('ignore a column', async ({ pass, teardown, equal }) => {
+  async function onDatabaseLoad (db, sql) {
+    pass('onDatabaseLoad called')
+    teardown(() => db.dispose())
+
+    await clear(db, sql)
+    await createBasicPages(db, sql)
+  }
+
+  const mapper = await connect({
+    ...connInfo,
+    log: fakeLogger,
+    onDatabaseLoad,
+    ignore: {
+      categories: {
+        name: true
+      }
+    }
+  })
+
+  const pageEntity = mapper.entities.page
+  equal(pageEntity.name, 'Page')
+
+  const categoryEntity = mapper.entities.category
+  equal(categoryEntity.name, 'Category')
+  equal(categoryEntity.fields.id.camelcase, 'id')
+  equal(categoryEntity.fields.name, undefined, 'name column is ignored')
+})
+
+test('shows a warning if there is no ignored column', async ({ plan, pass, teardown, equal }) => {
+  plan(4)
+
+  async function onDatabaseLoad (db, sql) {
+    pass('onDatabaseLoad called')
+    teardown(() => db.dispose())
+
+    await clear(db, sql)
+    await createBasicPages(db, sql)
+  }
+
+  const logger = {
+    trace: () => {},
+    error: () => {},
+    warn: (msg) => {
+      equal(msg, 'Ignored column "missing_column_name" not found. Did you mean "name"?')
+    }
+  }
+
+  const mapper = await connect({
+    ...connInfo,
+    log: logger,
+    onDatabaseLoad,
+    ignore: {
+      categories: {
+        missing_column_name: true
+      }
+    }
+  })
+
+  const pageEntity = mapper.entities.page
+  equal(pageEntity.name, 'Page')
+
+  const categoryEntity = mapper.entities.category
+  equal(categoryEntity.name, 'Category')
+})

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

@@ -89,7 +89,7 @@ expectType<SQLMapperPluginInterface<Entities>>(await connect<Entities>({
 
 const instance: FastifyInstance = fastify()
 instance.register(plugin, { connectionString: '', autoTimestamp: true })
-instance.register((instance) => { 
+instance.register((instance) => {
   expectType<SQLMapperPluginInterface<Entities>>(instance.platformatic)
 
   instance.platformatic.addEntityHooks<EntityFields>('something', {
@@ -136,4 +136,3 @@ expectType<ErrorWithTwoParams>(errors.ParamLimitNotAllowedError)
 expectType<ErrorWithOneParam>(errors.ParamLimitMustBeNotNegativeError)
 expectType<ErrorWithOneParam>(errors.MissingValueForPrimaryKeyError)
 expectType<ErrorWithNoParams>(errors.SQLiteOnlySupportsAutoIncrementOnOneColumnError)
-