sails-sqlite 0.0.0 → 0.2.0

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

@@ -0,0 +1,385 @@
+/**
+ * Generate SQL query for join operations in SQLite
+ * This follows SQLite performance best practices for optimal query performance
+ */
+
+module.exports = function generateJoinSqlQuery(joinCriteria, models, query) {
+  const _ = require('@sailshq/lodash')
+
+  try {
+    // Start building the SELECT clause
+    let sqlParts = {
+      select: [],
+      from: '',
+      joins: [],
+      where: [],
+      orderBy: [],
+      limit: '',
+      bindings: []
+    }
+
+    // Get the primary table info
+    const primaryTableName = query.using
+    const primaryModel = _.find(models, { tableName: primaryTableName })
+
+    if (!primaryModel) {
+      throw new Error(`Primary model not found for table: ${primaryTableName}`)
+    }
+
+    // Build SELECT clause - use explicit column names for better performance
+    if (query.criteria && query.criteria.select) {
+      sqlParts.select = query.criteria.select.map(
+        (col) => `${primaryTableName}.${col}`
+      )
+    } else {
+      // Select all columns from primary table with table prefix
+      const primaryCols = Object.keys(primaryModel.attributes).map((attr) => {
+        const colName = primaryModel.attributes[attr].columnName || attr
+        return `${primaryTableName}.${colName}`
+      })
+      sqlParts.select = primaryCols
+    }
+
+    // Add joined table columns
+    if (joinCriteria && joinCriteria.joins) {
+      joinCriteria.joins.forEach((join) => {
+        const joinModel = _.find(models, { tableName: join.child })
+        if (joinModel) {
+          const joinCols = Object.keys(joinModel.attributes).map((attr) => {
+            const colName = joinModel.attributes[attr].columnName || attr
+            return `${join.child}.${colName} as ${join.child}_${colName}`
+          })
+          sqlParts.select = sqlParts.select.concat(joinCols)
+        }
+      })
+    }
+
+    // FROM clause
+    sqlParts.from = primaryTableName
+
+    // JOIN clauses
+    if (joinCriteria && joinCriteria.joins) {
+      joinCriteria.joins.forEach((join) => {
+        let joinType = 'INNER JOIN' // Default to inner join
+
+        // Determine join type based on Waterline criteria
+        if (join.criteria && join.criteria.where) {
+          // This is a simplified check - you might need more sophisticated logic
+          joinType = 'LEFT JOIN'
+        }
+
+        // Build the JOIN clause with proper foreign key relationships
+        const joinClause = `${joinType} ${join.child} ON ${primaryTableName}.${join.parentKey} = ${join.child}.${join.childKey}`
+        sqlParts.joins.push(joinClause)
+      })
+    }
+
+    // WHERE clause - handle both primary and join criteria
+    const whereConditions = []
+
+    if (query.criteria && query.criteria.where) {
+      const primaryWhere = buildWhereClause(
+        query.criteria.where,
+        primaryTableName,
+        primaryModel
+      )
+      if (primaryWhere.clause) {
+        whereConditions.push(primaryWhere.clause)
+        sqlParts.bindings = sqlParts.bindings.concat(primaryWhere.bindings)
+      }
+    }
+
+    // Add join-specific where conditions
+    if (joinCriteria && joinCriteria.joins) {
+      joinCriteria.joins.forEach((join) => {
+        if (join.criteria && join.criteria.where) {
+          const joinModel = _.find(models, { tableName: join.child })
+          if (joinModel) {
+            const joinWhere = buildWhereClause(
+              join.criteria.where,
+              join.child,
+              joinModel
+            )
+            if (joinWhere.clause) {
+              whereConditions.push(joinWhere.clause)
+              sqlParts.bindings = sqlParts.bindings.concat(joinWhere.bindings)
+            }
+          }
+        }
+      })
+    }
+
+    sqlParts.where = whereConditions
+
+    // ORDER BY clause
+    if (query.criteria && query.criteria.sort) {
+      sqlParts.orderBy = query.criteria.sort.map((sortObj) => {
+        const key = Object.keys(sortObj)[0]
+        const direction = sortObj[key].toUpperCase()
+        return `${primaryTableName}.${key} ${direction}`
+      })
+    }
+
+    // LIMIT clause
+    if (query.criteria && typeof query.criteria.limit === 'number') {
+      sqlParts.limit = `LIMIT ${query.criteria.limit}`
+
+      if (typeof query.criteria.skip === 'number') {
+        sqlParts.limit += ` OFFSET ${query.criteria.skip}`
+      }
+    }
+
+    // Assemble the final SQL query
+    let sql = `SELECT ${sqlParts.select.join(', ')} FROM \`${sqlParts.from}\``
+
+    if (sqlParts.joins.length > 0) {
+      sql += ' ' + sqlParts.joins.join(' ')
+    }
+
+    if (sqlParts.where.length > 0) {
+      sql += ' WHERE ' + sqlParts.where.join(' AND ')
+    }
+
+    if (sqlParts.orderBy.length > 0) {
+      sql += ' ORDER BY ' + sqlParts.orderBy.join(', ')
+    }
+
+    if (sqlParts.limit) {
+      sql += ' ' + sqlParts.limit
+    }
+
+    return {
+      sql: sql,
+      bindings: sqlParts.bindings
+    }
+  } catch (error) {
+    throw new Error(`Error generating join SQL query: ${error.message}`)
+  }
+}
+
+/**
+ * Build WHERE clause for a given criteria object
+ * This handles parameterized queries for SQL injection protection
+ */
+function buildWhereClause(whereObj, tableName, model) {
+  const conditions = []
+  const bindings = []
+
+  if (!whereObj || typeof whereObj !== 'object') {
+    return { clause: '', bindings: [] }
+  }
+
+  for (const [key, value] of Object.entries(whereObj)) {
+    if (key === 'and') {
+      // Handle AND conditions
+      if (Array.isArray(value)) {
+        const andConditions = []
+        value.forEach((condition) => {
+          const subWhere = buildWhereClause(condition, tableName, model)
+          if (subWhere.clause) {
+            andConditions.push(subWhere.clause)
+            bindings.push(...subWhere.bindings)
+          }
+        })
+        if (andConditions.length > 0) {
+          conditions.push(`(${andConditions.join(' AND ')})`)
+        }
+      }
+    } else if (key === 'or') {
+      // Handle OR conditions
+      if (Array.isArray(value)) {
+        const orConditions = []
+        value.forEach((condition) => {
+          const subWhere = buildWhereClause(condition, tableName, model)
+          if (subWhere.clause) {
+            orConditions.push(subWhere.clause)
+            bindings.push(...subWhere.bindings)
+          }
+        })
+        if (orConditions.length > 0) {
+          conditions.push(`(${orConditions.join(' OR ')})`)
+        }
+      }
+    } else {
+      // Handle regular field conditions
+      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.
+        for (const [operator, operatorValue] of Object.entries(value)) {
+          switch (operator) {
+            case '>':
+              conditions.push(`${fullColumnName} > ?`)
+              bindings.push(operatorValue)
+              break
+            case '<':
+              conditions.push(`${fullColumnName} < ?`)
+              bindings.push(operatorValue)
+              break
+            case '>=':
+              conditions.push(`${fullColumnName} >= ?`)
+              bindings.push(operatorValue)
+              break
+            case '<=':
+              conditions.push(`${fullColumnName} <= ?`)
+              bindings.push(operatorValue)
+              break
+            case '!=':
+            case 'ne':
+              conditions.push(`${fullColumnName} != ?`)
+              bindings.push(operatorValue)
+              break
+            case 'in':
+              if (Array.isArray(operatorValue) && operatorValue.length > 0) {
+                const placeholders = operatorValue.map(() => '?').join(', ')
+                conditions.push(`${fullColumnName} IN (${placeholders})`)
+                bindings.push(...operatorValue)
+              }
+              break
+            case 'nin':
+              if (Array.isArray(operatorValue) && operatorValue.length > 0) {
+                const placeholders = operatorValue.map(() => '?').join(', ')
+                conditions.push(`${fullColumnName} NOT IN (${placeholders})`)
+                bindings.push(...operatorValue)
+              }
+              break
+            case 'like':
+              conditions.push(`${fullColumnName} LIKE ?`)
+              bindings.push(operatorValue)
+              break
+            case 'contains':
+              conditions.push(`${fullColumnName} LIKE ?`)
+              bindings.push(`%${operatorValue}%`)
+              break
+            case 'startsWith':
+              conditions.push(`${fullColumnName} LIKE ?`)
+              bindings.push(`${operatorValue}%`)
+              break
+            case 'endsWith':
+              conditions.push(`${fullColumnName} LIKE ?`)
+              bindings.push(`%${operatorValue}`)
+              break
+            default:
+              // Default to equality
+              conditions.push(`${fullColumnName} = ?`)
+              bindings.push(operatorValue)
+          }
+        }
+      } else {
+        // Simple equality
+        conditions.push(`${fullColumnName} = ?`)
+        bindings.push(value)
+      }
+    }
+  }
+
+  return {
+    clause: conditions.join(' AND '),
+    bindings: bindings
+  }
+}
+
+function generateSqlQuery(joinCriteria, models) {
+  const { parentStatement, joins } = joinCriteria
+  const tableName = parentStatement.from
+  const model = models[tableName]
+
+  let sql = `SELECT ${tableName}.*`
+  const bindings = []
+
+  // Add select clauses for joined tables
+  joins.forEach((join, index) => {
+    const joinModel = models[join.childCollectionIdentity]
+    const joinAlias = `t${index + 1}`
+    Object.keys(joinModel.definition).forEach((attr) => {
+      if (joinModel.definition[attr].columnName) {
+        sql += `, ${joinAlias}.${joinModel.definition[attr].columnName} AS ${joinAlias}_${attr}`
+      }
+    })
+  })
+
+  sql += ` FROM \`${tableName}\``
+
+  // Add join clauses
+  joins.forEach((join, index) => {
+    const joinType = join.type === 'INNER JOIN' ? 'INNER JOIN' : 'LEFT JOIN'
+    const joinAlias = `t${index + 1}`
+    sql += ` ${joinType} ${join.childCollectionIdentity} AS ${joinAlias} ON `
+
+    const joinConditions = []
+    Object.keys(join.on).forEach((key) => {
+      const parentField = model.definition[key].columnName || key
+      const childField =
+        models[join.childCollectionIdentity].definition[join.on[key]]
+          .columnName || join.on[key]
+      joinConditions.push(
+        `${tableName}.${parentField} = ${joinAlias}.${childField}`
+      )
+    })
+    sql += joinConditions.join(' AND ')
+  })
+
+  // Add where clause
+  if (parentStatement.where && Object.keys(parentStatement.where).length > 0) {
+    sql += ' WHERE '
+    const whereClauses = []
+    Object.entries(parentStatement.where).forEach(([key, value]) => {
+      if (typeof value === 'object' && value !== null) {
+        Object.entries(value).forEach(([operator, operand]) => {
+          switch (operator) {
+            case 'in':
+              whereClauses.push(
+                `${tableName}.${key} IN (${operand.map(() => '?').join(', ')})`
+              )
+              bindings.push(...operand)
+              break
+            case 'like':
+              whereClauses.push(`${tableName}.${key} LIKE ?`)
+              bindings.push(operand)
+              break
+            // Add more operators as needed
+          }
+        })
+      } else {
+        whereClauses.push(`${tableName}.${key} = ?`)
+        bindings.push(value)
+      }
+    })
+    sql += whereClauses.join(' AND ')
+  }
+
+  // Add order by clause
+  if (parentStatement.sort && parentStatement.sort.length > 0) {
+    sql +=
+      ' ORDER BY ' +
+      parentStatement.sort
+        .map((sortClause) => {
+          const direction = sortClause.dir === 'desc' ? 'DESC' : 'ASC'
+          return `${tableName}.${sortClause.attrName} ${direction}`
+        })
+        .join(', ')
+  }
+
+  // Add limit and skip
+  if (parentStatement.limit) {
+    sql += ' LIMIT ?'
+    bindings.push(parentStatement.limit)
+  }
+  if (parentStatement.skip) {
+    sql += ' OFFSET ?'
+    bindings.push(parentStatement.skip)
+  }
+
+  return { sql, bindings }
+}

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

@@ -0,0 +1,106 @@
+/**
+ * Process Each Record
+ *
+ * Process an array of records, transforming them from their raw SQLite format
+ * 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) {
+  // Validate options
+  if (!options || typeof options !== 'object') {
+    throw new Error(
+      'Invalid options argument. Options must contain: records, identity, and orm.'
+    )
+  }
+
+  const { records, identity, orm } = options
+
+  if (!Array.isArray(records)) {
+    throw new Error(
+      'Invalid option used in options argument. Missing or invalid records.'
+    )
+  }
+  if (typeof identity !== 'string') {
+    throw new Error(
+      'Invalid option used in options argument. Missing or invalid identity.'
+    )
+  }
+  if (typeof orm !== 'object') {
+    throw new Error(
+      'Invalid option used in options argument. Missing or invalid orm.'
+    )
+  }
+
+  // Key the collections by identity instead of column name
+  const collections = Object.fromEntries(
+    Object.entries(orm.collections).map(([key, val]) => [val.identity, val])
+  )
+
+  // Update the orm object with the keyed collections
+  orm.collections = collections
+
+  // Process each record
+  eachRecordDeep(
+    records,
+    (record, WLModel) => {
+      // 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) {
+          switch (attrDef.type) {
+            case 'boolean':
+              // SQLite stores booleans as integers, so we need to convert them
+              if (typeof record[columnName] !== 'boolean') {
+                record[columnName] = record[columnName] === 1
+              }
+              break
+
+            case 'json':
+              // SQLite stores JSON as text, so we need to parse it
+              if (record[columnName] !== null) {
+                try {
+                  record[columnName] = JSON.parse(record[columnName])
+                } catch (e) {
+                  console.warn(
+                    `Failed to parse JSON for attribute ${attrName}:`,
+                    e
+                  )
+                }
+              }
+              break
+
+            case 'number':
+              // Ensure numbers are actually numbers
+              record[columnName] = Number(record[columnName])
+              break
+
+            case 'date':
+            case 'datetime':
+              // SQLite doesn't have a native date type, so we need to parse it
+              if (
+                record[columnName] &&
+                typeof record[columnName] === 'string'
+              ) {
+                record[columnName] = new Date(record[columnName])
+              }
+              break
+
+            // Add more type conversions as needed
+          }
+        }
+      })
+    },
+    true,
+    identity,
+    orm
+  )
+}

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

@@ -0,0 +1,104 @@
+const flaverr = require('flaverr')
+
+module.exports = function processNativeError(err) {
+  if (err.footprint !== undefined) {
+    return new Error(
+      `Consistency violation: Raw error from SQLite arrived with a pre-existing \`footprint\` property! Should never happen... but maybe this error didn't actually come from SQLite..? Here's the error:\n\n\`\`\`\n${err.stack}\n\`\`\`\n`
+    )
+  }
+
+  // better-sqlite3 uses string-based error codes
+  switch (err.code) {
+    case 'SQLITE_CONSTRAINT':
+    case 'SQLITE_CONSTRAINT_UNIQUE':
+      // Check if it's a UNIQUE constraint violation
+      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+)/)
+        const keys = match && match[1] ? [match[1]] : []
+
+        return flaverr(
+          {
+            name: 'UsageError',
+            code: 'E_UNIQUE',
+            message: err.message,
+            footprint: {
+              identity: 'notUnique',
+              keys: keys
+            }
+          },
+          err
+        )
+      }
+
+      // Generic constraint violation
+      return flaverr(
+        {
+          name: 'UsageError',
+          code: 'E_CONSTRAINT',
+          message: err.message,
+          footprint: {
+            identity: 'violation',
+            keys: []
+          }
+        },
+        err
+      )
+
+    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
+      )
+
+    case 'SQLITE_FULL':
+      return flaverr(
+        {
+          name: 'UsageError',
+          code: 'E_FULL',
+          message: err.message,
+          footprint: {
+            identity: 'full'
+          }
+        },
+        err
+      )
+
+    default:
+      // For unhandled errors, return a generic error with footprint
+      return flaverr(
+        {
+          name: 'Error',
+          code: 'E_UNKNOWN',
+          message: err.message,
+          footprint: {
+            identity: 'catchall'
+          }
+        },
+        err
+      )
+  }
+}

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

@@ -0,0 +1,104 @@
+const assert = require('assert')
+
+/**
+ * processNativeRecord()
+ *
+ * Modify a native record coming back from the SQLite database so that it matches
+ * the expectations of the adapter spec (i.e. still a physical record, but
+ * minus any database-specific eccentricities).
+ *
+ * @param {Object} nativeRecord
+ * @param {Object} WLModel
+ * @param {Object?} meta       [`meta` query key from the s3q]
+ */
+module.exports = function processNativeRecord(nativeRecord, WLModel, meta) {
+  assert(nativeRecord !== undefined, '1st argument is required')
+  assert(
+    typeof nativeRecord === 'object' &&
+      nativeRecord !== null &&
+      !Array.isArray(nativeRecord),
+    '1st argument must be a dictionary'
+  )
+  assert(WLModel !== undefined, '2nd argument is required')
+  assert(
+    typeof WLModel === 'object' && WLModel !== null && !Array.isArray(WLModel),
+    '2nd argument must be a WLModel, and it has to have a `definition` property for this utility to work.'
+  )
+
+  // Check out each known attribute...
+  Object.entries(WLModel.attributes).forEach(([attrName, attrDef]) => {
+    const phRecordKey = attrDef.columnName
+
+    // Handle JSON type
+    if (
+      attrDef.type === 'json' &&
+      typeof nativeRecord[phRecordKey] === 'string'
+    ) {
+      try {
+        nativeRecord[phRecordKey] = JSON.parse(nativeRecord[phRecordKey])
+      } catch (e) {
+        // If parsing fails, leave the value as-is
+        console.warn(
+          `Failed to parse JSON for attribute ${attrName}: ${e.message}`
+        )
+      }
+    }
+
+    // Handle Date type
+    if (
+      attrDef.type === 'ref' &&
+      typeof nativeRecord[phRecordKey] === 'string'
+    ) {
+      const timestamp = Date.parse(nativeRecord[phRecordKey])
+      if (!isNaN(timestamp)) {
+        nativeRecord[phRecordKey] = new Date(timestamp)
+      }
+    }
+
+    // Handle Number type - SQLite returns numbers as strings with decimals
+    if (
+      attrDef.type === 'number' &&
+      typeof nativeRecord[phRecordKey] === 'string'
+    ) {
+      const numericValue = parseFloat(nativeRecord[phRecordKey])
+      if (!isNaN(numericValue)) {
+        nativeRecord[phRecordKey] = numericValue
+      }
+    }
+
+    // Handle Boolean type
+    if (attrDef.type === 'boolean') {
+      // SQLite stores booleans as integers (0 = false, 1 = true)
+      // But they come back as strings, so we need to parse them first
+      const rawValue = nativeRecord[phRecordKey]
+      if (rawValue !== undefined && rawValue !== null) {
+        const numericValue =
+          typeof rawValue === 'string' ? parseFloat(rawValue) : rawValue
+        nativeRecord[phRecordKey] = numericValue === 0 ? false : true
+      }
+    }
+
+    const isForeignKey = !!attrDef.model
+    // Sanity checks:
+    if (isForeignKey) {
+      assert(
+        attrDef.foreignKey,
+        'attribute has a `model` property, but wl-schema did not give it `foreignKey: true`!'
+      )
+    } else {
+      assert(
+        !attrDef.foreignKey,
+        'wl-schema gave this attribute `foreignKey: true`, but it has no `model` property!'
+      )
+    }
+
+    if (!isForeignKey) return
+    if (nativeRecord[phRecordKey] === undefined) return // This is weird, but WL core deals with warning about it.
+    if (nativeRecord[phRecordKey] === null) return
+
+    // For SQLite, we don't need to do any special processing for foreign keys
+    // as they are typically just stored as integers or strings.
+  })
+
+  return nativeRecord
+}