@platformatic/sql-mapper 0.22.0 → 0.23.0

package/lib/entity.js

@@ -14,7 +14,7 @@ function lowerCaseFirst (str) {
   return str.charAt(0).toLowerCase() + str.slice(1)
 }
 
-function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relations, queries, autoTimestamp, schema, useSchemaInName, limitConfig) {
+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)
   const entityName = useSchemaInName ? toUpperFirst(`${schema}${toSingular(table)}`) : toSingular(table)
   /* istanbul ignore next */
@@ -339,9 +339,9 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
   }
 }
 
-async function buildEntity (db, sql, log, table, queries, autoTimestamp, schema, useSchemaInName, ignore, limitConfig, schemaList) {
+function buildEntity (db, sql, log, table, queries, autoTimestamp, schema, useSchemaInName, ignore, limitConfig, schemaList, columns, constraintsList) {
   // Compute the columns
-  const columns = (await queries.listColumns(db, sql, table, schema)).filter((c) => !ignore[c.column_name])
+  columns = columns.filter((c) => !ignore[c.column_name])
   const fields = columns.reduce((acc, column) => {
     acc[column.column_name] = {
       sqlType: column.udt_name,
@@ -368,33 +368,26 @@ async function buildEntity (db, sql, log, table, queries, autoTimestamp, schema,
       acc[column.column_name].isGenerated = column.is_generated.includes('GENERATED')
     }
 
+    // To get enum values in pg
+    /* istanbul ignore next */
+    if (column.enum) {
+      acc[column.column_name].enum = column.enum
+    }
+
     return acc
   }, {})
 
-  // To get enum values in pg
-  /* istanbul ignore next */
-  if (db.isPg) {
-    const enums = await queries.listEnumValues(db, sql, table, schema)
-    for (const enumValue of enums) {
-      if (!fields[enumValue.column_name].enum) {
-        fields[enumValue.column_name].enum = [enumValue.enumlabel]
-      } else {
-        fields[enumValue.column_name].enum.push(enumValue.enumlabel)
-      }
-    }
-  }
   const currentRelations = []
 
-  const constraintsList = await queries.listConstraints(db, sql, table, schema)
   const primaryKeys = new Set()
 
   /* istanbul ignore next */
   function checkSQLitePrimaryKey (constraint) {
     if (db.isSQLite) {
-      const validTypes = ['integer', 'uuid', 'serial']
+      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. Expected "integer", found "${pkType}"`)
+        throw new Error(`Invalid Primary Key type: "${pkType}". We support the following: ${validTypes.join(', ')}.`)
       }
     }
   }

package/mapper.js

@@ -46,7 +46,7 @@ const defaultAutoTimestampFields = {
   updatedAt: 'updated_at'
 }
 
-async function connect ({ connectionString, log, onDatabaseLoad, poolSize = 10, ignore = {}, autoTimestamp = true, hooks = {}, schema, limit = {} }) {
+async function connect ({ connectionString, log, onDatabaseLoad, poolSize = 10, ignore = {}, autoTimestamp = true, hooks = {}, schema, limit = {}, dbschema }) {
   if (typeof autoTimestamp === 'boolean' && autoTimestamp === true) {
     autoTimestamp = defaultAutoTimestampFields
   }
@@ -110,9 +110,33 @@ async function connect ({ connectionString, log, onDatabaseLoad, poolSize = 10,
       await onDatabaseLoad(db, sql)
     }
 
-    const tablesWithSchema = await queries.listTables(db, sql, schemaList)
+    if (!dbschema) {
+      dbschema = await queries.listTables(db, sql, schemaList)
+
+      // TODO make this parallel or a single query
+      for (const wrap of dbschema) {
+        const { table, schema } = wrap
+        const columns = await queries.listColumns(db, sql, table, schema)
+        wrap.constraints = await queries.listConstraints(db, sql, table, schema)
+        wrap.columns = columns
+
+        // To get enum values in pg
+        /* istanbul ignore next */
+        if (db.isPg) {
+          const enums = await queries.listEnumValues(db, sql, table, schema)
+          for (const enumValue of enums) {
+            const column = columns.find(column => column.column_name === enumValue.column_name)
+            if (!column.enum) {
+              column.enum = [enumValue.enumlabel]
+            } else {
+              column.enum.push(enumValue.enumlabel)
+            }
+          }
+        }
+      }
+    }
 
-    for (const { table, schema } of tablesWithSchema) {
+    for (const { table, schema, columns, constraints } of dbschema) {
       // The following line is a safety net when developing this module,
       // it should never happen.
       /* istanbul ignore next */
@@ -122,7 +146,7 @@ async function connect ({ connectionString, log, onDatabaseLoad, poolSize = 10,
       if (ignore[table] === true) {
         continue
       }
-      const entity = await buildEntity(db, sql, log, table, queries, autoTimestamp, schema, useSchema, ignore[table] || {}, limit, schemaList)
+      const entity = buildEntity(db, sql, log, table, queries, autoTimestamp, schema, useSchema, ignore[table] || {}, limit, schemaList, columns, constraints)
       // Check for primary key of all entities
       if (entity.primaryKeys.size === 0) {
         log.warn({ table }, 'Cannot find any primary keys for table')
@@ -137,18 +161,19 @@ async function connect ({ connectionString, log, onDatabaseLoad, poolSize = 10,
         addEntityHooks(entity.singularName, hooks[entity.singularName])
       }
     }
+
+    return {
+      db,
+      sql,
+      entities,
+      addEntityHooks,
+      dbschema
+    }
   } catch (err) /* istanbul ignore next */ {
     db.dispose()
     throw err
   }
 
-  return {
-    db,
-    sql,
-    entities,
-    addEntityHooks
-  }
-
   function addEntityHooks (entityName, hooks) {
     const entity = entities[entityName]
     if (!entity) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/sql-mapper",
-  "version": "0.22.0",
+  "version": "0.23.0",
   "description": "A data mapper utility for SQL databases",
   "main": "mapper.js",
   "repository": {

package/test/entity.test.js

@@ -346,27 +346,32 @@ test('[SQLite] - UUID', { skip: !isSQLite }, async ({ pass, teardown, same, equa
   }
 })
 
-test('[SQLite] throws if PK is not INTEGER', { skip: !isSQLite }, async ({ fail, equal, teardown, rejects }) => {
+test('[SQLite] allows to have VARCHAR PK', { skip: !isSQLite }, async ({ same, teardown }) => {
   async function onDatabaseLoad (db, sql) {
     await clear(db, sql)
+    teardown(() => db.dispose())
+
     await db.query(sql`CREATE TABLE pages (
-      id int PRIMARY KEY,
-      title varchar(255) NOT NULL,
-      content text NOT NULL
+      id varchar(255) PRIMARY KEY,
+      title varchar(255) NOT NULL
     );`)
   }
-  try {
-    await connect({
-      connectionString: connInfo.connectionString,
-      log: fakeLogger,
-      onDatabaseLoad,
-      ignore: {},
-      hooks: {}
-    })
-    fail()
-  } catch (err) {
-    equal(err.message, 'Invalid Primary Key type. Expected "integer", found "int"')
-  }
+  const mapper = await connect({
+    connectionString: connInfo.connectionString,
+    log: fakeLogger,
+    onDatabaseLoad,
+    ignore: {},
+    hooks: {}
+  })
+  const pageEntity = mapper.entities.page
+  const [newPage] = await pageEntity.insert({
+    fields: ['id', 'title'],
+    inputs: [{ id: 'varchar_id', title: '13th page with explicit id equal to 13' }]
+  })
+  same(newPage, {
+    id: 'varchar_id',
+    title: '13th page with explicit id equal to 13'
+  })
 })
 
 test('mixing snake and camel case', async ({ pass, teardown, same, equal }) => {

package/test/no-primary-key.test.js

@@ -2,7 +2,7 @@
 
 const { test } = require('tap')
 
-const { clear, connInfo, isMysql8 } = require('./helper')
+const { clear, connInfo, isMysql8, isSQLite } = require('./helper')
 const { connect } = require('..')
 const fakeLogger = {
   trace: () => {},
@@ -36,7 +36,7 @@ test('unique key', async ({ equal, not, same, teardown }) => {
   equal(pageEntity.name, 'Page')
   equal(pageEntity.singularName, 'page')
   equal(pageEntity.pluralName, 'pages')
-  if (isMysql8) {
+  if (isMysql8 || isSQLite) {
     same(pageEntity.primaryKeys, new Set(['name']))
     equal(pageEntity.camelCasedFields.name.primaryKey, true)
   } else {

package/test/schema.test.js

@@ -61,7 +61,7 @@ test('uses tables from different schemas', { skip: isSQLite }, async ({ pass, te
   pass()
 })
 
-test('find enums correctly using schemas', { skip: isSQLite }, async ({ pass, teardown, equal }) => {
+test('find enums correctly using schemas', { skip: isSQLite }, async ({ pass, teardown, equal, match }) => {
   async function onDatabaseLoad (db, sql) {
     await clear(db, sql)
     teardown(() => db.dispose())
@@ -102,6 +102,31 @@ test('find enums correctly using schemas', { skip: isSQLite }, async ({ pass, te
   equal(pageEntity.name, 'Test1Page')
   equal(pageEntity.singularName, 'test1Page')
   equal(pageEntity.pluralName, 'test1Pages')
+  match(mapper.dbschema, [
+    {
+      schema: 'test1',
+      table: 'pages',
+      constraints: [
+        {
+          constraint_type: isMysql8 ? 'UNIQUE' : 'PRIMARY KEY'
+        }
+      ],
+      columns: [
+        {
+          column_name: 'id',
+          is_nullable: 'NO'
+        },
+        {
+          column_name: 'title',
+          is_nullable: 'NO'
+        },
+        {
+          column_name: 'type',
+          is_nullable: 'YES'
+        }
+      ]
+    }
+  ])
   pass()
 })
 
@@ -379,3 +404,71 @@ test('uses tables from different schemas with FK', { skip: isSQLite }, async ({
   equal(userRelation.entityName, 'test2User')
   pass()
 })
+
+test('recreate mapper from schema', async ({ pass, teardown, equal, match, fail }) => {
+  async function onDatabaseLoad (db, sql) {
+    await clear(db, sql)
+    teardown(() => db.dispose())
+
+    if (isMysql || isMysql8) {
+      await db.query(sql`
+      CREATE TABLE IF NOT EXISTS \`pages\` (
+        id SERIAL PRIMARY KEY,
+        title VARCHAR(255) NOT NULL
+    );`)
+    } else if (isPg) {
+      await db.query(sql`
+      CREATE TABLE IF NOT EXISTS "pages" (
+      id SERIAL PRIMARY KEY,
+      title VARCHAR(255) NOT NULL
+    );`)
+    } else if (isSQLite) {
+      await db.query(sql`
+      CREATE TABLE IF NOT EXISTS "pages" (
+      id INTEGER PRIMARY KEY,
+      title VARCHAR(255) NOT NULL
+    );`)
+    } else {
+      await db.query(sql`CREATE TABLE IF NOT EXISTS "pages" (
+      id SERIAL PRIMARY KEY,
+      title VARCHAR(255) NOT NULL,
+    );`)
+    }
+  }
+  const mapper = await connect({
+    connectionString: connInfo.connectionString,
+    log: fakeLogger,
+    onDatabaseLoad,
+    ignore: {},
+    hooks: {}
+  })
+  const dbschema = mapper.dbschema
+  const knownQueries = [
+    'SELECT VERSION()'
+  ]
+  const mapper2 = await connect({
+    connectionString: connInfo.connectionString,
+    log: {
+      trace (msg) {
+        if (knownQueries.indexOf(msg.query?.text) < 0) {
+          console.log(msg)
+          fail('no trace')
+        }
+      },
+      error (...msg) {
+        console.log(...msg)
+        fail('no error')
+      }
+    },
+    dbschema,
+    ignore: {},
+    hooks: {}
+  })
+  teardown(() => mapper2.db.dispose())
+
+  const pageEntity = mapper2.entities.page
+  equal(pageEntity.name, 'Page')
+  equal(pageEntity.singularName, 'page')
+  equal(pageEntity.pluralName, 'pages')
+  pass()
+})