sails-sqlite 0.0.0 → 0.2.0

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

@@ -0,0 +1,120 @@
+const assert = require('assert')
+const util = require('util')
+const processNativeRecord = require('./private/process-native-record')
+const buildSqliteWhereClause = require('./private/build-sqlite-where-clause')
+
+module.exports = {
+  friendlyName: 'Find (records)',
+
+  description: 'Find record(s) in the SQLite database.',
+
+  inputs: {
+    query: require('../constants/query.input'),
+    connection: require('../constants/connection.input'),
+    dryOrm: require('../constants/dry-orm.input')
+  },
+
+  exits: {
+    success: {
+      outputFriendlyName: 'Records',
+      outputDescription: 'An array of physical records.',
+      outputExample: '===' //[ {===} ]
+    }
+  },
+
+  fn: async function (inputs, exits) {
+    const s3q = inputs.query
+    if (s3q.meta && s3q.meta.logSqliteS3Qs) {
+      console.log(
+        '* * * * * *\nADAPTER (FIND RECORDS):',
+        util.inspect(s3q, { depth: 10 }),
+        '\n'
+      )
+    }
+
+    const tableName = s3q.using
+    // Find model by tableName since models is an object, not an array
+    let WLModel = null
+    for (const modelIdentity in inputs.dryOrm.models) {
+      if (inputs.dryOrm.models[modelIdentity].tableName === tableName) {
+        WLModel = inputs.dryOrm.models[modelIdentity]
+        break
+      }
+    }
+
+    if (!WLModel) {
+      return exits.error(
+        new Error(
+          `No model with that tableName (\`${tableName}\`) has been registered with this adapter. Were any unexpected modifications made to the stage 3 query? Could the adapter's internal state have been corrupted? (This error is usually due to a bug in this adapter's implementation.)`
+        )
+      )
+    }
+
+    const db = inputs.connection
+
+    try {
+      let sqlQuery = `SELECT `
+
+      // Handle SELECT clause
+      if (s3q.criteria.select) {
+        sqlQuery += s3q.criteria.select.map((col) => `\`${col}\``).join(', ')
+      } else {
+        sqlQuery += '*'
+      }
+
+      sqlQuery += ` FROM \`${tableName}\``
+
+      // Handle WHERE clause
+      const whereClause = buildSqliteWhereClause(
+        s3q.criteria.where,
+        WLModel,
+        s3q.meta
+      )
+      if (whereClause) {
+        sqlQuery += ` WHERE ${whereClause}`
+      }
+
+      // Handle SORT clause
+      if (s3q.criteria.sort && s3q.criteria.sort.length) {
+        const sortClauses = s3q.criteria.sort.map((sortObj) => {
+          const key = Object.keys(sortObj)[0]
+          const direction = sortObj[key] === 'ASC' ? 'ASC' : 'DESC'
+          return `\`${key}\` ${direction}`
+        })
+        sqlQuery += ` ORDER BY ${sortClauses.join(', ')}`
+      }
+
+      // Handle LIMIT clause
+      // If no limit is specified, don't add LIMIT clause (will return all matching records)
+      // This handles cases where Waterline doesn't provide a default limit
+      if (
+        s3q.criteria.limit !== undefined &&
+        Number.isFinite(s3q.criteria.limit)
+      ) {
+        sqlQuery += ` LIMIT ${s3q.criteria.limit}`
+      }
+
+      // Handle SKIP (OFFSET) clause
+      if (s3q.criteria.skip) {
+        sqlQuery += ` OFFSET ${s3q.criteria.skip}`
+      }
+
+      // Use prepared statement caching for better performance
+      const stmt = db.getPreparedStatement
+        ? db.getPreparedStatement(sqlQuery)
+        : db.prepare(sqlQuery)
+
+      const nativeResult = stmt.all()
+
+      // Process records
+      const phRecords = nativeResult.map((record) => {
+        processNativeRecord(record, WLModel, s3q.meta)
+        return record
+      })
+
+      return exits.success(phRecords)
+    } catch (err) {
+      return exits.error(err)
+    }
+  }
+}

package/lib/private/machines/get-connection.js

@@ -0,0 +1,54 @@
+module.exports = {
+  friendlyName: 'Get connection',
+
+  description:
+    'Get an active connection to the SQLite database (this is a no-op for SQLite).',
+
+  moreInfoUrl:
+    'https://github.com/node-machine/driver-interface/blob/master/machines/get-connection.js',
+
+  sync: true,
+
+  inputs: {
+    manager: {
+      description: 'A SQLite database instance (from better-sqlite3).',
+      example: '===',
+      required: true
+    },
+
+    meta: {
+      friendlyName: 'Meta (unused)',
+      description: 'Additional stuff to pass to the driver.',
+      example: '==='
+    }
+  },
+
+  exits: {
+    success: {
+      outputFriendlyName: 'Report',
+      outputDescription:
+        'The `connection` property is a SQLite database instance. The `meta` property is unused.',
+      outputExample: '==='
+    },
+
+    failed: {
+      friendlyName: 'Failed (unused)',
+      description:
+        'Could not acquire a connection to the database via the provided connection manager. (This is unlikely to occur with SQLite)',
+      outputFriendlyName: 'Report',
+      outputExample: {
+        error: '===',
+        meta: '==='
+      }
+    }
+  },
+
+  fn: ({ manager, meta }, exits) => {
+    // This is a no-op that just sends back the manager and `meta` that were passed in.
+    // In SQLite, the "manager" and "connection" are the same thing: a Database instance from better-sqlite3.
+    return exits.success({
+      connection: manager,
+      meta
+    })
+  }
+}

package/lib/private/machines/join.js

@@ -0,0 +1,259 @@
+module.exports = {
+  friendlyName: 'Join',
+  description: 'Perform a join operation in SQLite using better-sqlite3.',
+  inputs: {
+    query: require('../constants/query.input'),
+    connection: require('../constants/connection.input'),
+    dryOrm: require('../constants/dry-orm.input')
+  },
+  exits: {
+    success: {
+      description: 'The query was run successfully.',
+      outputType: 'ref'
+    },
+    error: {
+      description: 'An error occurred while performing the query.'
+    }
+  },
+  fn: function (inputs, exits) {
+    const _ = require('@sailshq/lodash')
+    const async = require('async')
+    const WLUtils = require('waterline-utils')
+    const processEachRecord = require('./private/process-each-record')
+    const compileStatement = require('./private/compile-statement')
+
+    const { query, connection, dryOrm } = inputs
+    const models = dryOrm.models
+
+    let hasReturned = false
+
+    // Find the model definition
+    const model = models[query.using]
+    if (!model) {
+      if (hasReturned) return
+      hasReturned = true
+      return exits.error(new Error(`No model found for table: ${query.using}`))
+    }
+
+    // Get primary key info
+    const primaryKeyAttr = model.primaryKey
+    const primaryKeyColumnName =
+      model.definition[primaryKeyAttr].columnName || primaryKeyAttr
+
+    // Build statements
+    const statements = WLUtils.joins.convertJoinCriteria({
+      query,
+      getPk: function getPk(tableName) {
+        let targetModel = null
+        for (const modelIdentity in models) {
+          if (models[modelIdentity].tableName === tableName) {
+            targetModel = models[modelIdentity]
+            break
+          }
+        }
+        if (!targetModel) {
+          throw new Error('Invalid parent table name')
+        }
+        const pkAttrName = targetModel.primaryKey
+        const pkColumnName =
+          targetModel.definition[pkAttrName].columnName || pkAttrName
+        return pkColumnName
+      }
+    })
+
+    // Run parent query
+    const compiledQuery = compileStatement(statements.parentStatement)
+    const db = connection
+    const stmt = db.prepare(compiledQuery.sql)
+    const parentResults = stmt.all(...(compiledQuery.bindings || []))
+
+    // Early exit if no joins or no results
+    if (!_.has(query, 'joins') || !parentResults.length) {
+      if (hasReturned) return
+      hasReturned = true
+      return exits.success(parentResults)
+    }
+
+    // Detect child records
+    const sortedResults = WLUtils.joins.detectChildrenRecords(
+      primaryKeyColumnName,
+      parentResults
+    )
+
+    // Initialize query cache
+    const queryCache = WLUtils.joins.queryCache()
+
+    // Process instructions
+    _.each(statements.instructions, function (val, key) {
+      const popInstructions = val.instructions
+      const strategy = val.strategy.strategy
+      const parentModel = models[_.first(popInstructions).parent]
+
+      if (!parentModel) {
+        throw new Error('Invalid parent model in instructions')
+      }
+
+      const pkAttr = parentModel.primaryKey
+      const pkColumnName = parentModel.definition[pkAttr].columnName || pkAttr
+
+      let alias, keyName
+      if (val.strategy && val.strategy.strategy === 1) {
+        alias = _.first(popInstructions).alias
+        keyName = _.first(popInstructions).parentKey
+      } else {
+        alias = _.first(popInstructions).alias
+      }
+
+      _.each(sortedResults.parents, function (parentRecord) {
+        const cache = {
+          attrName: key,
+          parentPkAttr: pkColumnName,
+          belongsToPkValue: parentRecord[pkColumnName],
+          keyName: keyName || alias,
+          type: strategy
+        }
+
+        const childKey = _.first(popInstructions).childKey
+        const parentKey = _.first(popInstructions).parentKey
+
+        const records = _.filter(
+          sortedResults.children[alias],
+          function (child) {
+            if (strategy === 3) {
+              return child._parent_fk === parentRecord[parentKey]
+            }
+            return child[childKey] === parentRecord[parentKey]
+          }
+        )
+
+        if (strategy === 3) {
+          _.each(records, function (record) {
+            delete record._parent_fk
+          })
+        }
+
+        if (records.length) {
+          cache.records = records
+        }
+
+        queryCache.set(cache)
+      })
+    })
+
+    // Set parents
+    queryCache.setParents(sortedResults.parents)
+
+    // Single-query path (no child statements)
+    if (!statements.childStatements || !statements.childStatements.length) {
+      const combinedResults = queryCache.combineRecords() || []
+      const orm = { collections: models }
+      processEachRecord({
+        records: combinedResults,
+        identity: model.identity,
+        orm: orm
+      })
+      if (hasReturned) return
+      hasReturned = true
+      return exits.success(combinedResults)
+    }
+
+    // Multi-query path (process child statements)
+    const parentKeys = _.map(queryCache.getParents(), function (record) {
+      return record[primaryKeyColumnName]
+    })
+
+    async.each(
+      statements.childStatements,
+      function (template, next) {
+        // Handle IN queries
+        if (template.queryType === 'in') {
+          const inClause = _.pullAt(
+            template.statement.where.and,
+            template.statement.where.and.length - 1
+          )
+          const clause = _.first(inClause)
+          _.each(clause, function (val) {
+            val.in = parentKeys
+          })
+          template.statement.where.and.push(clause)
+        }
+
+        // Handle UNION queries with special case for per-entity pagination
+        if (template.queryType === 'union') {
+          const unionStatements = []
+          _.each(parentKeys, function (parentPk) {
+            const unionStatement = _.merge({}, template.statement)
+            const andClause = _.pullAt(
+              unionStatement.where.and,
+              unionStatement.where.and.length - 1
+            )
+            _.each(_.first(andClause), function (val, key) {
+              _.first(andClause)[key] = parentPk
+            })
+            unionStatement.where.and.push(_.first(andClause))
+            unionStatements.push(unionStatement)
+          })
+
+          if (unionStatements.length) {
+            // Check if this is per-entity pagination (has LIMIT/OFFSET)
+            const hasPerEntityPagination =
+              unionStatements[0].limit || unionStatements[0].skip
+
+            if (hasPerEntityPagination && unionStatements.length > 1) {
+              // SQLite-savvy approach: Execute separate queries for per-entity pagination
+              const allChildResults = []
+
+              _.each(unionStatements, function (singleStatement) {
+                const compiledQuery = compileStatement(singleStatement)
+                const stmt = db.prepare(compiledQuery.sql)
+                const results = stmt.all(...(compiledQuery.bindings || []))
+                allChildResults.push(...results)
+              })
+
+              // Extend cache with combined results
+              queryCache.extend(allChildResults, template.instructions)
+              return next()
+            } else {
+              // Standard UNION approach for non-pagination cases
+              template.statement = { unionAll: unionStatements }
+            }
+          }
+        }
+
+        if (!template.statement) {
+          return next()
+        }
+
+        // Run child query
+        const childCompiledQuery = compileStatement(template.statement)
+        const childStmt = db.prepare(childCompiledQuery.sql)
+        const childResults = childStmt.all(
+          ...(childCompiledQuery.bindings || [])
+        )
+
+        // Extend cache
+        queryCache.extend(childResults, template.instructions)
+        next()
+      },
+      function (err) {
+        if (hasReturned) return
+
+        if (err) {
+          hasReturned = true
+          return exits.error(err)
+        }
+
+        // Final combine and return
+        const combinedResults = queryCache.combineRecords() || []
+        const orm = { collections: models }
+        processEachRecord({
+          records: combinedResults,
+          identity: model.identity,
+          orm: orm
+        })
+        hasReturned = true
+        return exits.success(combinedResults)
+      }
+    )
+  }
+}

package/lib/private/machines/lease-connection.js

@@ -0,0 +1,58 @@
+/**
+ * Module dependencies
+ */
+
+/**
+ * Lease Connection
+ *
+ * Get a dedicated connection from the datastore for use in transactions.
+ * For SQLite, this returns the same connection manager since SQLite is single-threaded.
+ */
+
+module.exports = {
+  friendlyName: 'Lease connection',
+
+  description:
+    'Get a dedicated connection from the datastore for use in transactions.',
+
+  moreInfoUrl:
+    'https://github.com/WiseLibs/better-sqlite3/blob/master/docs/api.md',
+
+  inputs: {
+    manager: {
+      description: 'The connection manager instance to get a connection from.',
+      example: '===',
+      required: true
+    },
+
+    meta: {
+      description: 'Additional options for this query.',
+      example: '==='
+    }
+  },
+
+  exits: {
+    failed: {
+      description: 'Could not get a connection to the database.'
+    },
+
+    success: {
+      description: 'A connection was successfully leased.',
+      outputExample: '==='
+    }
+  },
+
+  fn: function leaseConnection(inputs, exits) {
+    const manager = inputs.manager
+    const meta = inputs.meta || {}
+
+    try {
+      // For SQLite, the manager IS the database connection
+      // SQLite is single-threaded and doesn't support concurrent transactions
+      // The "connection" is actually the database instance
+      return exits.success(manager)
+    } catch (err) {
+      return exits.failed(err)
+    }
+  }
+}

package/lib/private/machines/private/build-sqlite-where-clause.js

@@ -0,0 +1,91 @@
+/**
+ * buildSqliteWhereClause()
+ *
+ * Build a SQLite WHERE clause from the specified S3Q `where` clause.
+ * > Note: The provided `where` clause is NOT mutated.
+ *
+ * @param  {Object} whereClause [`where` clause from the criteria of a S3Q]
+ * @param  {Object} WLModel
+ * @param  {Object?} meta       [`meta` query key from the s3q]
+ *
+ * @returns {String}            [SQLite WHERE clause]
+ */
+module.exports = function buildSqliteWhereClause(whereClause, WLModel, meta) {
+  // Handle null, undefined, or empty `where` clause.
+  if (!whereClause || Object.keys(whereClause).length === 0) {
+    return ''
+  }
+
+  // Recursively build and return a transformed `where` clause for use with SQLite.
+  function recurse(branch, isRoot = true) {
+    const clauses = []
+    for (const [key, value] of Object.entries(branch)) {
+      if (key === 'and' || key === 'or') {
+        const subClauses = value.map((subBranch) => recurse(subBranch, false))
+        clauses.push(`(${subClauses.join(` ${key.toUpperCase()} `)})`)
+      } else {
+        clauses.push(buildConstraint(key, value, WLModel, meta))
+      }
+    }
+    return isRoot ? clauses.join(' AND ') : clauses.join(' AND ')
+  }
+
+  return recurse(whereClause)
+}
+
+function buildConstraint(columnName, constraint, WLModel, meta) {
+  if (typeof constraint !== 'object' || constraint === null) {
+    return `${columnName} = ${sqliteEscape(constraint)}`
+  }
+
+  const modifierKind = Object.keys(constraint)[0]
+  const modifier = constraint[modifierKind]
+
+  switch (modifierKind) {
+    case '<':
+      return `${columnName} < ${sqliteEscape(modifier)}`
+    case '<=':
+      return `${columnName} <= ${sqliteEscape(modifier)}`
+    case '>':
+      return `${columnName} > ${sqliteEscape(modifier)}`
+    case '>=':
+      return `${columnName} >= ${sqliteEscape(modifier)}`
+    case '!=':
+      return `${columnName} != ${sqliteEscape(modifier)}`
+    case 'nin':
+      return `${columnName} NOT IN (${modifier.map(sqliteEscape).join(', ')})`
+    case 'in':
+      return `${columnName} IN (${modifier.map(sqliteEscape).join(', ')})`
+    case 'like':
+      // SQLite uses LIKE with % and _ wildcards (not REGEXP)
+      let likePattern = modifier
+      // Convert JavaScript-style wildcards to SQL LIKE wildcards if needed
+      if (!likePattern.includes('%') && !likePattern.includes('_')) {
+        // If no wildcards, assume they want contains behavior
+        likePattern = `%${likePattern}%`
+      }
+      let clause = `${columnName} LIKE '${likePattern.replace(/'/g, "''")}'`
+      if (meta && meta.makeLikeModifierCaseInsensitive === true) {
+        clause = `LOWER(${columnName}) LIKE LOWER('${likePattern.replace(/'/g, "''")}')`
+      }
+      return clause
+    default:
+      throw new Error(
+        `Consistency violation: \`where\` clause modifier \`${modifierKind}\` is not valid! This should never happen-- a stage 3 query should have already been normalized in Waterline core.`
+      )
+  }
+}
+
+function sqliteEscape(value) {
+  if (typeof value === 'string') {
+    return `'${value.replace(/'/g, "''")}'`
+  }
+  if (typeof value === 'boolean') {
+    // Match the decimal format that SQLite stores (1.0, 0.0)
+    return value ? '1.0' : '0.0'
+  }
+  if (value === null) {
+    return 'NULL'
+  }
+  return value
+}