@platformatic/sql-mapper 0.13.0 → 0.14.0

package/lib/entity.js

@@ -330,7 +330,7 @@ function createMapper (defaultDb, sql, log, table, fields, primaryKeys, relation
   }
 }
 
-async function buildEntity (db, sql, log, table, queries, autoTimestamp, schema, useSchemaInName, ignore, limitConfig) {
+async function buildEntity (db, sql, log, table, queries, autoTimestamp, schema, useSchemaInName, ignore, limitConfig, schemaList) {
   // Compute the columns
   const columns = (await queries.listColumns(db, sql, table, schema)).filter((c) => !ignore[c.column_name])
   const fields = columns.reduce((acc, column) => {
@@ -409,15 +409,14 @@ async function buildEntity (db, sql, log, table, queries, autoTimestamp, schema,
       field.primaryKey = true
     }
 
-    if (constraint.constraint_type === 'FOREIGN KEY') {
+    // we need to ignore for coverage here because cannot be covered with sqlite (no schema support)
+    // istanbul ignore next
+    const isForeignKeySchemaInConfig = schemaList?.length > 0 ? schemaList.includes(constraint.foreign_table_schema) : true
+    /* istanbul ignore if */
+    if (constraint.constraint_type === 'FOREIGN KEY' && isForeignKeySchemaInConfig) {
       field.foreignKey = true
-
-      // we need to ignore for coverage here becasue cannot be covered with sqlite (no schema support)
-      // istanbul ignore next
       const foreignEntityName = singularize(camelcase(useSchemaInName ? camelcase(`${constraint.foreign_table_schema} ${constraint.foreign_table_name}`) : constraint.foreign_table_name))
-      // istanbul ignore next
       const entityName = singularize(camelcase(useSchemaInName ? camelcase(`${constraint.table_schema} ${constraint.table_name}`) : constraint.table_name))
-      // istanbul ignore next
       const loweredTableWithSchemaName = lowerCaseFirst(useSchemaInName ? camelcase(`${constraint.table_schema} ${camelcase(constraint.table_name)}`) : camelcase(constraint.table_name))
       constraint.loweredTableWithSchemaName = loweredTableWithSchemaName
       constraint.foreignEntityName = foreignEntityName

package/lib/queries/sqlite.js

@@ -85,67 +85,73 @@ async function listConstraints (db, sql, table) {
 module.exports.listConstraints = listConstraints
 
 async function insertOne (db, sql, table, schema, input, primaryKeys, fieldsToRetrieve) {
-  const fieldNames = Object.keys(input)
-  const keysToSql = fieldNames.map((key) => sql.ident(key))
-  const valuesToSql = fieldNames.map((key) => sql.value(input[key]))
-
   const primaryKeyValues = {}
-  let useUUID = false
-  const where = []
-  let autoIncrement = 0
+
+  let hasAutoIncrementPK = false
+
   for (const { key, sqlType } of primaryKeys) {
-    keysToSql.push(sql.ident(key))
-    // TODO figure out while this is not covered by tests
+    let primaryKeyValue = input[key]
+
     /* istanbul ignore next */
-    if (sqlType === 'uuid') {
-      useUUID = true
-      primaryKeyValues[key] = randomUUID()
-    } else if (autoIncrement > 1) {
-      throw new Error('SQLite only supports autoIncrement on one column')
-    } else if (input[key]) {
-      primaryKeyValues[key] = input[key]
-    } else {
-      autoIncrement++
-      primaryKeyValues[key] = null
+    if (primaryKeyValue === undefined) {
+      if (sqlType === 'uuid') {
+        primaryKeyValue = randomUUID()
+      } else if (!hasAutoIncrementPK) {
+        primaryKeyValue = null
+        hasAutoIncrementPK = true
+      } else {
+        throw new Error('SQLite only supports autoIncrement on one column')
+      }
+      input[key] = primaryKeyValue
     }
-    valuesToSql.push(sql.value(primaryKeyValues[key]))
+
+    primaryKeyValues[key] = primaryKeyValue
   }
 
-  const keys = sql.join(
-    keysToSql,
-    sql`, `
-  )
+  const insertedKeys = []
+  const insertedValues = []
 
-  const values = sql.join(
-    valuesToSql,
-    sql`, `
-  )
+  for (const [key, value] of Object.entries(input)) {
+    insertedKeys.push(sql.ident(key))
+    insertedValues.push(sql.value(value))
+  }
 
-  const insert = sql`
-    INSERT INTO ${sql.ident(table)} (${keys})
-    VALUES(${values})
+  const insertRawQuery = sql`
+    INSERT INTO ${sql.ident(table)} (${sql.join(insertedKeys, sql`, `)})
+    VALUES(${sql.join(insertedValues, sql`, `)})
   `
-  await db.query(insert)
-
-  if (!useUUID && primaryKeys.length === 1) {
-    const res2 = await db.query(sql`
-      SELECT last_insert_rowid()
-    `)
-
-    primaryKeyValues[primaryKeys[0].key] = res2[0]['last_insert_rowid()']
-  }
 
-  for (const { key } of primaryKeys) {
-    where.push(sql`${sql.ident(key)} = ${sql.value(primaryKeyValues[key])}`)
+  if (fieldsToRetrieve.length === 0) {
+    await db.query(insertRawQuery)
+    return {}
+  } else {
+    return db.tx(async (transaction) => {
+      await transaction.query(insertRawQuery)
+
+      let selectInsertedRawQuery = null
+      if (hasAutoIncrementPK) {
+        selectInsertedRawQuery = sql`
+          SELECT ${sql.join(fieldsToRetrieve, sql`, `)}
+          FROM ${sql.ident(table)}
+          WHERE _rowid_ = last_insert_rowid()
+        `
+      } else {
+        const where = []
+        for (const [key, value] of Object.entries(primaryKeyValues)) {
+          where.push(sql`${sql.ident(key)} = ${sql.value(value)}`)
+        }
+
+        selectInsertedRawQuery = sql`
+          SELECT ${sql.join(fieldsToRetrieve, sql`, `)}
+          FROM ${sql.ident(table)}
+          WHERE ${sql.join(where, sql` AND `)}
+        `
+      }
+
+      const [insertedRaw] = await transaction.query(selectInsertedRawQuery)
+      return insertedRaw
+    })
   }
-
-  const res = await db.query(sql`
-    SELECT ${sql.join(fieldsToRetrieve, sql`, `)}
-    FROM ${sql.ident(table)}
-    WHERE ${sql.join(where, sql` AND `)}
-  `)
-
-  return res[0]
 }
 
 module.exports.insertOne = insertOne

package/mapper.js

@@ -122,7 +122,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)
+      const entity = await buildEntity(db, sql, log, table, queries, autoTimestamp, schema, useSchema, ignore[table] || {}, limit, schemaList)
       // Check for primary key of all entities
       if (entity.primaryKeys.size === 0) {
         log.warn({ table }, 'Cannot find any primary keys for table')

package/package.json

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

package/test/entity.test.js

@@ -43,7 +43,7 @@ test('entity fields', async ({ equal, not, same, teardown }) => {
   equal(pageEntity.camelCasedFields.id.primaryKey, true)
 })
 
-test('entity API', { only: true }, async ({ equal, same, teardown, rejects }) => {
+test('entity API', async ({ equal, same, teardown, rejects }) => {
   async function onDatabaseLoad (db, sql) {
     await clear(db, sql)
     teardown(() => db.dispose())
@@ -168,7 +168,7 @@ test('empty save', async ({ equal, same, teardown, rejects }) => {
   same(insertResult, { id: '1', theTitle: null })
 })
 
-test('insert with explicit PK value', async ({ same, teardown }) => {
+test('insert with explicit integer PK value', async ({ same, teardown }) => {
   async function onDatabaseLoad (db, sql) {
     await clear(db, sql)
     teardown(() => db.dispose())
@@ -195,6 +195,108 @@ test('insert with explicit PK value', async ({ same, teardown }) => {
   })
 })
 
+test('insert with explicit uuid PK value', { 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 uuid PRIMARY KEY,
+      title varchar(255) NOT NULL
+    );`)
+  }
+  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: '00000000-0000-0000-0000-000000000013',
+      title: '13th page with explicit id equal to 13'
+    }]
+  })
+  same(newPage, {
+    id: '00000000-0000-0000-0000-000000000013',
+    title: '13th page with explicit id equal to 13'
+  })
+})
+
+test('insert with explicit uuid PK value without rowid', { 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 uuid PRIMARY KEY,
+      title varchar(255) NOT NULL
+    ) WITHOUT ROWID;`)
+  }
+  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: '00000000-0000-0000-0000-000000000013',
+      title: '13th page with explicit id equal to 13'
+    }]
+  })
+  same(newPage, {
+    id: '00000000-0000-0000-0000-000000000013',
+    title: '13th page with explicit id equal to 13'
+  })
+})
+
+test('insert without fields to retrieve', { 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 INTEGER PRIMARY KEY,
+      title varchar(255) NOT NULL
+    );`)
+  }
+  const mapper = await connect({
+    connectionString: connInfo.connectionString,
+    log: fakeLogger,
+    onDatabaseLoad,
+    ignore: {},
+    hooks: {}
+  })
+
+  const pageEntity = mapper.entities.page
+  await pageEntity.insert({
+    fields: [],
+    inputs: [{
+      id: '13',
+      title: '13th page with explicit id equal to 13'
+    }]
+  })
+
+  const [newPage] = await pageEntity.find({
+    where: {
+      id: {
+        eq: '13'
+      }
+    }
+  })
+
+  same(newPage, {
+    id: '13',
+    title: '13th page with explicit id equal to 13'
+  })
+})
+
 test('[SQLite] - UUID', { skip: !isSQLite }, async ({ pass, teardown, same, equal }) => {
   const mapper = await connect({
     connectionString: connInfo.connectionString,