sails-sqlite 0.1.0 → 0.2.0

package/lib/private/machines/private/compile-statement.js

@@ -0,0 +1,334 @@
+/**
+ * Compile a Waterline statement into a native SQLite query
+ */
+
+const buildSqliteWhereClause = require('./build-sqlite-where-clause')
+
+module.exports = function compileStatement(statement) {
+  if (!statement) {
+    throw new Error('Statement is required')
+  }
+
+  let sql = ''
+  let bindings = []
+
+  // Handle UNION ALL queries
+  if (statement.unionAll && Array.isArray(statement.unionAll)) {
+    const unionQueries = []
+    let globalOrderBy = null
+
+    statement.unionAll.forEach((unionStatement) => {
+      let processedStatement = { ...unionStatement }
+
+      // Remove ORDER BY, LIMIT, SKIP from individual queries - apply globally
+      if (!globalOrderBy && unionStatement.orderBy) {
+        globalOrderBy = unionStatement.orderBy
+      }
+      delete processedStatement.orderBy
+      delete processedStatement.limit
+      delete processedStatement.skip
+
+      const compiledUnion = compileStatement(processedStatement)
+      unionQueries.push(compiledUnion.sql)
+      bindings = bindings.concat(compiledUnion.bindings || [])
+    })
+
+    sql = unionQueries.join(' UNION ALL ')
+
+    // Apply global ORDER BY if present
+    if (
+      globalOrderBy &&
+      Array.isArray(globalOrderBy) &&
+      globalOrderBy.length > 0
+    ) {
+      const orderClauses = globalOrderBy.map((orderItem) => {
+        if (typeof orderItem === 'string') {
+          return `\`${orderItem}\` ASC`
+        }
+        if (typeof orderItem === 'object') {
+          const key = Object.keys(orderItem)[0]
+          const direction =
+            orderItem[key].toUpperCase() === 'DESC' ? 'DESC' : 'ASC'
+          return `\`${key}\` ${direction}`
+        }
+        return orderItem
+      })
+      sql += ` ORDER BY ${orderClauses.join(', ')}`
+    }
+
+    return { sql, bindings }
+  }
+
+  // Handle regular SELECT statements
+  if (statement.select) {
+    // SELECT clause
+    if (Array.isArray(statement.select) && statement.select.length > 0) {
+      const selectColumns = statement.select.map((col) => {
+        // Handle columns with aliases (e.g., 'table.column as alias')
+        if (col.includes(' as ')) {
+          const [columnPart, aliasPart] = col.split(' as ')
+          const alias = aliasPart.trim()
+
+          // Process the column part
+          let formattedColumn
+          if (columnPart.includes('.')) {
+            const parts = columnPart.split('.')
+            if (parts.length === 2) {
+              const [tableName, columnName] = parts
+              formattedColumn = `\`${tableName}\`.\`${columnName}\``
+            } else {
+              formattedColumn = columnPart
+            }
+          } else {
+            formattedColumn = `\`${columnPart}\``
+          }
+
+          return `${formattedColumn} AS ${alias}`
+        }
+        // Handle table-prefixed columns (e.g., 'tableName.columnName')
+        else if (col.includes('.')) {
+          const parts = col.split('.')
+          if (parts.length === 2) {
+            const [tableName, columnName] = parts
+            return `\`${tableName}\`.\`${columnName}\``
+          }
+          // Handle complex column expressions
+          return col
+        } else {
+          return `\`${col}\``
+        }
+      })
+      sql += `SELECT ${selectColumns.join(', ')}`
+    } else {
+      sql += 'SELECT *'
+    }
+
+    // FROM clause
+    if (statement.from) {
+      // Handle table aliases (e.g., "paymentTable as paymentTable__payments")
+      if (statement.from.includes(' as ')) {
+        const [tableName, alias] = statement.from.split(' as ')
+        sql += ` FROM \`${tableName.trim()}\` AS \`${alias.trim()}\``
+      } else {
+        sql += ` FROM \`${statement.from}\``
+      }
+    }
+
+    // JOIN clauses
+    if (statement.leftOuterJoin && Array.isArray(statement.leftOuterJoin)) {
+      statement.leftOuterJoin.forEach((join) => {
+        if (join.from && join.on) {
+          // Handle table aliases in JOIN
+          let joinTable
+          if (join.from.includes(' as ')) {
+            const [tableName, alias] = join.from.split(' as ')
+            joinTable = `\`${tableName.trim()}\` AS \`${alias.trim()}\``
+          } else {
+            joinTable = `\`${join.from}\``
+          }
+
+          sql += ` LEFT OUTER JOIN ${joinTable} ON `
+
+          // Build the ON conditions
+          const onConditions = []
+          Object.keys(join.on).forEach((tableName) => {
+            const columnName = join.on[tableName]
+            // The key is a table name, value is a column name
+            // We need to format as table.column for both sides
+            const formattedTableCol = `\`${tableName}\`.\`${columnName}\``
+            onConditions.push(formattedTableCol)
+          })
+
+          // Join conditions should be joined with =
+          // If we have 2 conditions, it should be table1.col1 = table2.col2
+          if (onConditions.length === 2) {
+            sql += `${onConditions[0]} = ${onConditions[1]}`
+          } else {
+            // Fallback for other cases
+            sql += onConditions.join(' AND ')
+          }
+        }
+      })
+    }
+
+    // WHERE clause
+    if (statement.where) {
+      const whereResult = buildWhereClause(statement.where)
+      if (whereResult.clause) {
+        sql += ` WHERE ${whereResult.clause}`
+        bindings = bindings.concat(whereResult.bindings || [])
+      }
+    }
+
+    // ORDER BY clause
+    if (
+      statement.orderBy &&
+      Array.isArray(statement.orderBy) &&
+      statement.orderBy.length > 0
+    ) {
+      const orderClauses = statement.orderBy.map((orderItem) => {
+        if (typeof orderItem === 'string') {
+          return `\`${orderItem}\` ASC`
+        }
+        if (typeof orderItem === 'object') {
+          const key = Object.keys(orderItem)[0]
+          const direction =
+            orderItem[key].toUpperCase() === 'DESC' ? 'DESC' : 'ASC'
+          return `\`${key}\` ${direction}`
+        }
+        return orderItem
+      })
+      sql += ` ORDER BY ${orderClauses.join(', ')}`
+    }
+
+    // LIMIT clause
+    if (typeof statement.limit === 'number') {
+      sql += ` LIMIT ${statement.limit}`
+    }
+
+    // OFFSET clause
+    if (typeof statement.skip === 'number') {
+      sql += ` OFFSET ${statement.skip}`
+    }
+  }
+
+  return { sql, bindings }
+}
+
+/**
+ * Build WHERE clause from Waterline criteria
+ */
+function buildWhereClause(whereObj) {
+  if (!whereObj || typeof whereObj !== 'object') {
+    return { clause: '', bindings: [] }
+  }
+
+  const conditions = []
+  const bindings = []
+
+  // Handle AND conditions
+  if (whereObj.and && Array.isArray(whereObj.and)) {
+    const andConditions = []
+    whereObj.and.forEach((condition) => {
+      const result = buildWhereClause(condition)
+      if (result.clause) {
+        andConditions.push(result.clause)
+        bindings.push(...result.bindings)
+      }
+    })
+    if (andConditions.length > 0) {
+      conditions.push(`(${andConditions.join(' AND ')})`)
+    }
+  }
+
+  // Handle OR conditions
+  if (whereObj.or && Array.isArray(whereObj.or)) {
+    const orConditions = []
+    whereObj.or.forEach((condition) => {
+      const result = buildWhereClause(condition)
+      if (result.clause) {
+        orConditions.push(result.clause)
+        bindings.push(...result.bindings)
+      }
+    })
+    if (orConditions.length > 0) {
+      conditions.push(`(${orConditions.join(' OR ')})`)
+    }
+  }
+
+  // Handle field conditions
+  Object.keys(whereObj).forEach((key) => {
+    if (key === 'and' || key === 'or') {
+      return // Already handled above
+    }
+
+    const value = whereObj[key]
+    let columnName
+
+    // Handle table.column format
+    if (key.includes('.')) {
+      const parts = key.split('.')
+      if (parts.length === 2) {
+        const [tableName, colName] = parts
+        columnName = `\`${tableName}\`.\`${colName}\``
+      } else {
+        columnName = key // fallback for complex expressions
+      }
+    } else {
+      columnName = `\`${key}\``
+    }
+
+    if (typeof value === 'object' && value !== null) {
+      // Handle operators
+      Object.keys(value).forEach((operator) => {
+        const operatorValue = value[operator]
+
+        switch (operator) {
+          case 'in':
+            if (Array.isArray(operatorValue) && operatorValue.length > 0) {
+              const placeholders = operatorValue.map(() => '?').join(', ')
+              conditions.push(`${columnName} IN (${placeholders})`)
+              bindings.push(...operatorValue)
+            }
+            break
+          case 'nin':
+            if (Array.isArray(operatorValue) && operatorValue.length > 0) {
+              const placeholders = operatorValue.map(() => '?').join(', ')
+              conditions.push(`${columnName} NOT IN (${placeholders})`)
+              bindings.push(...operatorValue)
+            }
+            break
+          case '>':
+            conditions.push(`${columnName} > ?`)
+            bindings.push(operatorValue)
+            break
+          case '>=':
+            conditions.push(`${columnName} >= ?`)
+            bindings.push(operatorValue)
+            break
+          case '<':
+            conditions.push(`${columnName} < ?`)
+            bindings.push(operatorValue)
+            break
+          case '<=':
+            conditions.push(`${columnName} <= ?`)
+            bindings.push(operatorValue)
+            break
+          case '!=':
+          case 'ne':
+            conditions.push(`${columnName} != ?`)
+            bindings.push(operatorValue)
+            break
+          case 'like':
+            conditions.push(`${columnName} LIKE ?`)
+            bindings.push(operatorValue)
+            break
+          case 'contains':
+            conditions.push(`${columnName} LIKE ?`)
+            bindings.push(`%${operatorValue}%`)
+            break
+          case 'startsWith':
+            conditions.push(`${columnName} LIKE ?`)
+            bindings.push(`${operatorValue}%`)
+            break
+          case 'endsWith':
+            conditions.push(`${columnName} LIKE ?`)
+            bindings.push(`%${operatorValue}`)
+            break
+          default:
+            conditions.push(`${columnName} = ?`)
+            bindings.push(operatorValue)
+        }
+      })
+    } else {
+      // Simple equality
+      conditions.push(`${columnName} = ?`)
+      bindings.push(value)
+    }
+  })
+
+  return {
+    clause: conditions.join(' AND '),
+    bindings: bindings
+  }
+}

package/lib/private/machines/private/generate-join-sql-query.js

@@ -130,7 +130,7 @@ module.exports = function generateJoinSqlQuery(joinCriteria, models, query) {
     }
 
     // Assemble the final SQL query
-    let sql = `SELECT ${sqlParts.select.join(', ')} FROM ${sqlParts.from}`
+    let sql = `SELECT ${sqlParts.select.join(', ')} FROM \`${sqlParts.from}\``
 
     if (sqlParts.joins.length > 0) {
       sql += ' ' + sqlParts.joins.join(' ')
@@ -202,10 +202,18 @@ function buildWhereClause(whereObj, tableName, model) {
       }
     } else {
       // Handle regular field conditions
-      const columnName = model.attributes[key]
-        ? model.attributes[key].columnName || key
-        : key
-      const fullColumnName = `${tableName}.${columnName}`
+      let fullColumnName
+      if (key.includes('.')) {
+        // If the key already contains a table reference (e.g., "customerTable._id"),
+        // use it as-is instead of prepending the table name again
+        fullColumnName = key
+      } else {
+        // Otherwise, construct the full column name normally
+        const columnName = model.attributes[key]
+          ? model.attributes[key].columnName || key
+          : key
+        fullColumnName = `${tableName}.${columnName}`
+      }
 
       if (typeof value === 'object' && value !== null) {
         // Handle operators like >, <, !=, in, etc.
@@ -301,7 +309,7 @@ function generateSqlQuery(joinCriteria, models) {
     })
   })
 
-  sql += ` FROM ${tableName}`
+  sql += ` FROM \`${tableName}\``
 
   // Add join clauses
   joins.forEach((join, index) => {

package/lib/private/machines/private/process-each-record.js

@@ -5,6 +5,7 @@
  * to the format expected by Waterline. This follows performance best practices.
  */
 
+const _ = require('@sailshq/lodash')
 const { eachRecordDeep } = require('waterline-utils')
 
 module.exports = function processEachRecord(options) {
@@ -45,7 +46,13 @@ module.exports = function processEachRecord(options) {
   eachRecordDeep(
     records,
     (record, WLModel) => {
-      for (const [attrName, attrDef] of Object.entries(WLModel.definition)) {
+      // Guard against null/undefined WLModel or definition
+      if (!WLModel || !WLModel.definition) {
+        return
+      }
+
+      // Use _.each instead of Object.entries for compatibility
+      _.each(WLModel.definition, (attrDef, attrName) => {
         const columnName = attrDef.columnName || attrName
 
         if (columnName in record) {
@@ -90,7 +97,7 @@ module.exports = function processEachRecord(options) {
             // Add more type conversions as needed
           }
         }
-      }
+      })
     },
     true,
     identity,

package/lib/private/machines/private/process-native-error.js

@@ -1,3 +1,5 @@
+const flaverr = require('flaverr')
+
 module.exports = function processNativeError(err) {
   if (err.footprint !== undefined) {
     return new Error(
@@ -5,55 +7,98 @@ module.exports = function processNativeError(err) {
     )
   }
 
-  // SQLite error codes
-  const SQLITE_CONSTRAINT = 19
-  const SQLITE_BUSY = 5
-  const SQLITE_READONLY = 8
-  const SQLITE_FULL = 13
-
+  // better-sqlite3 uses string-based error codes
   switch (err.code) {
-    case SQLITE_CONSTRAINT:
-      err.footprint = {
-        identity: 'violation',
-        keys: []
-      }
-
+    case 'SQLITE_CONSTRAINT':
+    case 'SQLITE_CONSTRAINT_UNIQUE':
       // Check if it's a UNIQUE constraint violation
-      if (err.message.includes('UNIQUE constraint failed')) {
-        err.footprint.identity = 'notUnique'
+      if (
+        err.code === 'SQLITE_CONSTRAINT_UNIQUE' ||
+        err.message.includes('UNIQUE constraint failed')
+      ) {
+        // Extract the column name from the error message
         const match = err.message.match(/UNIQUE constraint failed: \w+\.(\w+)/)
-        if (match && match[1]) {
-          err.footprint.keys.push(match[1])
-        }
-      }
-      break
+        const keys = match && match[1] ? [match[1]] : []
 
-    case SQLITE_BUSY:
-      err.footprint = {
-        identity: 'busy'
+        return flaverr(
+          {
+            name: 'UsageError',
+            code: 'E_UNIQUE',
+            message: err.message,
+            footprint: {
+              identity: 'notUnique',
+              keys: keys
+            }
+          },
+          err
+        )
       }
-      break
 
-    case SQLITE_READONLY:
-      err.footprint = {
-        identity: 'readonly'
-      }
-      break
+      // Generic constraint violation
+      return flaverr(
+        {
+          name: 'UsageError',
+          code: 'E_CONSTRAINT',
+          message: err.message,
+          footprint: {
+            identity: 'violation',
+            keys: []
+          }
+        },
+        err
+      )
 
-    case SQLITE_FULL:
-      err.footprint = {
-        identity: 'full'
-      }
-      break
+    case 'SQLITE_BUSY':
+      return flaverr(
+        {
+          name: 'UsageError',
+          code: 'E_BUSY',
+          message: err.message,
+          footprint: {
+            identity: 'busy'
+          }
+        },
+        err
+      )
+
+    case 'SQLITE_READONLY':
+      return flaverr(
+        {
+          name: 'UsageError',
+          code: 'E_READONLY',
+          message: err.message,
+          footprint: {
+            identity: 'readonly'
+          }
+        },
+        err
+      )
 
-    // Add more cases as needed for other error types
+    case 'SQLITE_FULL':
+      return flaverr(
+        {
+          name: 'UsageError',
+          code: 'E_FULL',
+          message: err.message,
+          footprint: {
+            identity: 'full'
+          }
+        },
+        err
+      )
 
     default:
-      // For unhandled errors, we might want to set a generic footprint
-      err.footprint = {
-        identity: 'error'
-      }
+      // For unhandled errors, return a generic error with footprint
+      return flaverr(
+        {
+          name: 'Error',
+          code: 'E_UNKNOWN',
+          message: err.message,
+          footprint: {
+            identity: 'catchall'
+          }
+        },
+        err
+      )
   }
-
-  return err
 }

package/lib/private/machines/rollback-transaction.js

@@ -0,0 +1,50 @@
+/**
+ * Module dependencies
+ */
+
+/**
+ * Rollback Transaction
+ *
+ * Rollback the current database transaction on the provided connection.
+ */
+
+module.exports = {
+  friendlyName: 'Rollback transaction',
+
+  description:
+    'Rollback the current database transaction on the provided connection.',
+
+  moreInfoUrl:
+    'https://github.com/WiseLibs/better-sqlite3/blob/master/docs/api.md#transactionfunction---function',
+
+  inputs: {
+    connection: {
+      description:
+        'An active database connection that was acquired from a manager.',
+      example: '===',
+      required: true
+    },
+
+    meta: {
+      description: 'Additional options for this query.',
+      example: '==='
+    }
+  },
+
+  fn: function rollbackTransaction(inputs, exits) {
+    const db = inputs.connection
+    const meta = inputs.meta || {}
+
+    try {
+      if (!db.inTransaction) {
+        return exits.error(new Error('No active transaction to rollback.'))
+      }
+
+      db.prepare('ROLLBACK TRANSACTION').run()
+
+      return exits.success()
+    } catch (err) {
+      return exits.error(err)
+    }
+  }
+}

package/lib/private/machines/sum-records.js

@@ -59,7 +59,7 @@ module.exports = {
     const db = inputs.connection
 
     try {
-      let sumQuery = `SELECT COALESCE(SUM(${numericFieldName}), 0) as total FROM ${tableName}`
+      let sumQuery = `SELECT COALESCE(SUM(\`${numericFieldName}\`), 0) as total FROM \`${tableName}\``
       if (whereClause) {
         sumQuery += ` WHERE ${whereClause}`
       }

package/lib/private/machines/update-records.js

@@ -72,24 +72,33 @@ module.exports = {
 
     const db = inputs.connection
 
+    // Check if we're already in a transaction
+    const wasInTransaction = db.inTransaction
+
     try {
-      // Start a transaction
-      db.exec('BEGIN TRANSACTION')
+      // Start a transaction only if we're not already in one
+      if (!wasInTransaction) {
+        db.exec('BEGIN TRANSACTION')
+      }
 
       let affectedIds = []
 
       if (isFetchEnabled) {
         // Get the IDs of records which match this criteria
-        const selectSql = `SELECT ${pkColumnName} FROM ${tableName} WHERE ${sqliteWhere}`
+        const selectSql = sqliteWhere
+          ? `SELECT \`${pkColumnName}\` FROM \`${tableName}\` WHERE ${sqliteWhere}`
+          : `SELECT \`${pkColumnName}\` FROM \`${tableName}\``
         const selectStmt = db.prepare(selectSql)
         affectedIds = selectStmt.all().map((row) => row[pkColumnName])
       }
 
       // Prepare the UPDATE statement
       const setClauses = Object.entries(s3q.valuesToSet)
-        .map(([column, value]) => `${column} = ?`)
+        .map(([column, value]) => `\`${column}\` = ?`)
         .join(', ')
-      const updateSql = `UPDATE ${tableName} SET ${setClauses} WHERE ${sqliteWhere}`
+      const updateSql = sqliteWhere
+        ? `UPDATE \`${tableName}\` SET ${setClauses} WHERE ${sqliteWhere}`
+        : `UPDATE \`${tableName}\` SET ${setClauses}`
       const updateStmt = db.prepare(updateSql)
 
       // Execute the UPDATE
@@ -107,7 +116,9 @@ module.exports = {
         s3q.valuesToSet[pkColumnName] !== undefined &&
         affectedIds.length > 1
       ) {
-        db.exec('ROLLBACK')
+        if (!wasInTransaction) {
+          db.exec('ROLLBACK')
+        }
         return exits.error(
           new Error(
             'Consistency violation: Updated multiple records to have the same primary key value. (PK values should be unique!)'
@@ -117,12 +128,14 @@ module.exports = {
 
       // If fetch is not enabled, we're done
       if (!isFetchEnabled) {
-        db.exec('COMMIT')
+        if (!wasInTransaction) {
+          db.exec('COMMIT')
+        }
         return exits.success()
       }
 
       // Fetch the updated records
-      const fetchSql = `SELECT * FROM ${tableName} WHERE ${pkColumnName} IN (${affectedIds.map(() => '?').join(', ')})`
+      const fetchSql = `SELECT * FROM \`${tableName}\` WHERE \`${pkColumnName}\` IN (${affectedIds.map(() => '?').join(', ')})`
       const fetchStmt = db.prepare(fetchSql)
       const phRecords = fetchStmt.all(affectedIds)
 
@@ -131,10 +144,14 @@ module.exports = {
         processNativeRecord(phRecord, WLModel, s3q.meta)
       })
 
-      db.exec('COMMIT')
+      if (!wasInTransaction) {
+        db.exec('COMMIT')
+      }
       return exits.success(phRecords)
     } catch (err) {
-      db.exec('ROLLBACK')
+      if (!wasInTransaction) {
+        db.exec('ROLLBACK')
+      }
       err = processNativeError(err)
       if (err.footprint && err.footprint.identity === 'notUnique') {
         return exits.notUnique(err)