sails-sqlite 0.0.0 → 0.1.0

package/lib/private/machines/create-record.js

@@ -0,0 +1,126 @@
+module.exports = {
+  friendlyName: 'Create (record)',
+
+  description: 'Create a new physical record in the SQLite database.',
+
+  inputs: {
+    query: require('../constants/query.input'),
+    connection: require('../constants/connection.input'),
+    dryOrm: require('../constants/dry-orm.input')
+  },
+
+  exits: {
+    success: {
+      outputFriendlyName: 'Record (maybe)',
+      outputDescription:
+        'Either `null` or (if `fetch:true`) a dictionary representing the new record that was created.',
+      outputExample: '==='
+    },
+    notUnique: require('../constants/not-unique.exit')
+  },
+
+  fn: function (inputs, exits) {
+    // Dependencies
+    const util = require('util')
+    const _ = require('@sailshq/lodash')
+    const processNativeRecord = require('./private/process-native-record')
+    const processNativeError = require('./private/process-native-error')
+    const reifyValuesToSet = require('./private/reify-values-to-set')
+
+    // Local var for the stage 3 query, for easier access.
+    const s3q = inputs.query
+    if (s3q.meta && s3q.meta.logSQLiteS3Qs) {
+      console.log(
+        '* * * * * *\nADAPTER (CREATE RECORD):',
+        util.inspect(s3q, { depth: 5 }),
+        '\n'
+      )
+    }
+
+    // Local var for the `tableName`, for clarity.
+    const tableName = s3q.using
+
+    // Grab the model definition
+    const WLModel = _.find(inputs.dryOrm.models, { tableName: tableName })
+    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.)`
+        )
+      )
+    }
+
+    // Reify values to set
+    try {
+      reifyValuesToSet(s3q.newRecord, WLModel, s3q.meta)
+    } catch (e) {
+      return exits.error(e)
+    }
+
+    // Determine whether to fetch or not
+    const isFetchEnabled = !!(s3q.meta && s3q.meta.fetch)
+
+    // Create this new record in the SQLite database
+    const db = inputs.connection
+
+    try {
+      // Build column names and values arrays
+      const columnNames = Object.keys(s3q.newRecord)
+      const columnValues = Object.values(s3q.newRecord)
+
+      // Validate that we have data to insert
+      if (columnNames.length === 0) {
+        throw new Error('Cannot create record: no data provided')
+      }
+
+      // Prepare the INSERT statement with proper SQL escaping
+      const columns = columnNames.join(', ')
+      const placeholders = columnNames.map(() => '?').join(', ')
+      const sql = `INSERT INTO \`${tableName}\` (${columns}) VALUES (${placeholders})`
+
+      // Use prepared statement (optimized for repeated use)
+      const stmt = db.getPreparedStatement
+        ? db.getPreparedStatement(sql)
+        : db.prepare(sql)
+
+      // Execute the INSERT statement within a transaction for consistency
+      const info = db.runInTransaction
+        ? db.runInTransaction(() => stmt.run(columnValues))
+        : stmt.run(columnValues)
+
+      // If `fetch` is NOT enabled, we're done.
+      if (!isFetchEnabled) {
+        return exits.success()
+      }
+
+      // Otherwise, fetch the newly created record
+      const selectSql = `SELECT * FROM ${tableName} WHERE rowid = ?`
+      const selectStmt = db.prepare(selectSql)
+      const phRecord = selectStmt.get(info.lastInsertRowid)
+
+      if (!phRecord) {
+        return exits.error(
+          new Error(
+            'Consistency violation: Unable to retrieve the inserted record. This might indicate a consistency violation.'
+          )
+        )
+      }
+
+      try {
+        // Process record (mutate in-place) to wash away adapter-specific eccentricities.
+        processNativeRecord(phRecord, WLModel, s3q.meta)
+      } catch (e) {
+        return exits.error(e)
+      }
+
+      // Send back the record
+      return exits.success(phRecord)
+    } catch (err) {
+      err = processNativeError(err)
+      if (err.footprint && err.footprint.identity === 'notUnique') {
+        return exits.notUnique(err)
+      }
+      return exits.error(err)
+    }
+  }
+}

package/lib/private/machines/define-physical-model.js

@@ -0,0 +1,102 @@
+module.exports = {
+  friendlyName: 'Define (physical model)',
+
+  description:
+    'Define a physical model (i.e. SQLite table) with the specified characteristics, creating indexes as needed.',
+
+  sideEffects: 'idempotent',
+
+  inputs: {
+    connection: require('../constants/connection.input'),
+    tableName: require('../constants/table-name.input'),
+    columns: {
+      description: 'An array of column definitions.',
+      required: true,
+      example: '==='
+    },
+    meta: require('../constants/meta.input')
+  },
+
+  exits: {
+    success: {
+      description:
+        'New physical model (and any necessary indexes) were created successfully.'
+    }
+  },
+
+  fn: function (inputs, exits) {
+    const db = inputs.connection
+    function getSqliteType(columnType) {
+      if (!columnType || typeof columnType !== 'string') {
+        return 'TEXT' // Default fallback
+      }
+      switch (columnType.toLowerCase()) {
+        case '_string':
+        case '_text':
+        case '_mediumtext':
+        case '_longtext':
+          return 'TEXT'
+        case '_number':
+        case '_numberkey':
+        case '_numbertimestamp':
+        case 'integer':
+        case 'int':
+          return 'INTEGER'
+        case '_json':
+          return 'TEXT'
+        case 'float':
+        case 'double':
+        case 'real':
+          return 'REAL'
+        case 'boolean':
+          return 'INTEGER'
+        case 'date':
+        case 'datetime':
+          return 'TEXT'
+        case 'binary':
+        case 'blob':
+          return 'BLOB'
+        default:
+          return 'TEXT'
+      }
+    }
+
+    try {
+      // Start a transaction
+      db.prepare('BEGIN').run()
+
+      // Build and execute the CREATE TABLE statement
+      let createTableSQL = `CREATE TABLE IF NOT EXISTS ${inputs.tableName} (`
+      let columnDefs = inputs.columns.map((column) => {
+        const columnType = column.columnType ?? column.type
+        let def = `${column.columnName} ${column.autoIncrement ? 'INTEGER' : getSqliteType(columnType)}`
+        if (column.autoIncrement) {
+          def += ' PRIMARY KEY AUTOINCREMENT NOT NULL'
+        }
+        if (column.unique && !column.autoIncrement) def += ' UNIQUE'
+        return def
+      })
+      createTableSQL += columnDefs.join(', ') + ')'
+      db.prepare(createTableSQL).run()
+
+      // Create indexes
+      inputs.columns.forEach((column) => {
+        if (column.unique && !column.autoIncrement) {
+          const indexSQL = `CREATE UNIQUE INDEX IF NOT EXISTS idx_${inputs.tableName}_${column.columnName} ON ${inputs.tableName} (${column.columnName})`
+          db.prepare(indexSQL).run()
+        }
+      })
+
+      // Commit the transaction
+      db.prepare('COMMIT').run()
+
+      return exits.success()
+    } catch (error) {
+      // If there's an error, roll back the transaction
+      db.prepare('ROLLBACK').run()
+      return exits.error(
+        new Error(`Error defining table ${inputs.tableName}: ${error.message}`)
+      )
+    }
+  }
+}

package/lib/private/machines/destroy-manager.js

@@ -0,0 +1,87 @@
+module.exports = {
+  friendlyName: 'Destroy manager',
+
+  description: 'Destroy the specified SQLite connection manager.',
+
+  extendedDescription:
+    'For SQLite, this involves closing the database connection. Unlike other databases, SQLite does not use connection pools, so this operation is relatively straightforward.',
+
+  sync: true,
+
+  inputs: {
+    manager: {
+      description: 'The SQLite connection manager instance to destroy.',
+      extendedDescription:
+        'Only managers built using the `createManager()` method of this driver are supported. The database connection manager instance provided must not have been destroyed previously.',
+      example: '===',
+      required: true
+    },
+
+    meta: {
+      friendlyName: 'Meta (custom)',
+      description: 'Additional options to pass to the SQLite driver.',
+      extendedDescription:
+        'This is reserved for custom driver-specific extensions. Please refer to the better-sqlite3 documentation for more specific information.',
+      example: '==='
+    }
+  },
+
+  exits: {
+    success: {
+      description: 'The specified SQLite manager was successfully destroyed.',
+      outputFriendlyName: 'Report',
+      outputDescription:
+        'The `meta` property is reserved for custom driver-specific extensions.',
+      outputExample: '==='
+    }
+  },
+
+  fn: ({ manager, meta }, exits) => {
+    try {
+      // Validate the manager
+      if (
+        typeof manager !== 'object' ||
+        manager === null ||
+        typeof manager.close !== 'function'
+      ) {
+        return exits.error(
+          new Error(
+            'The provided `manager` is not a valid SQLite manager. It should be a better-sqlite3 Database instance with a `close` method.'
+          )
+        )
+      }
+
+      // Check if the database is already closed
+      if (!manager.open) {
+        console.warn(
+          'SQLite manager appears to already be closed, skipping destruction'
+        )
+        return exits.success({ meta })
+      }
+
+      // Use graceful cleanup if available (from enhanced create-manager)
+      if (typeof manager.closeGracefully === 'function') {
+        manager.closeGracefully()
+      } else {
+        // Fallback to basic close
+        manager.close()
+      }
+
+      // Verify the connection is actually closed
+      if (manager.open) {
+        throw new Error('Failed to close SQLite database connection')
+      }
+
+      return exits.success({
+        meta: {
+          ...meta,
+          destroyedAt: new Date().toISOString()
+        }
+      })
+    } catch (error) {
+      return exits.error(
+        new Error(`Error destroying SQLite manager: ${error.message}`)
+      )
+    }
+  }
+}

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

@@ -0,0 +1,101 @@
+const util = require('util')
+const processNativeRecord = require('./private/process-native-record')
+const buildSqliteWhereClause = require('./private/build-sqlite-where-clause')
+
+module.exports = {
+  friendlyName: 'Destroy (records)',
+
+  description:
+    'Destroy record(s) in the SQLite database matching a query criteria.',
+
+  inputs: {
+    query: require('../constants/query.input'),
+    connection: require('../constants/connection.input'),
+    dryOrm: require('../constants/dry-orm.input')
+  },
+
+  exits: {
+    success: {
+      outputFriendlyName: 'Records (maybe)',
+      outputDescription:
+        'Either `null` OR (if `fetch:true`) an array of physical records that were destroyed.',
+      outputExample: '==='
+    }
+  },
+
+  fn: async function (inputs, exits) {
+    const s3q = inputs.query
+    if (s3q.meta && s3q.meta.logSqliteS3Qs) {
+      console.log(
+        '* * * * * *\nADAPTER (DESTROY RECORDS):',
+        util.inspect(s3q, { depth: 5 }),
+        '\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 pkColumnName = WLModel.attributes[WLModel.primaryKey].columnName
+    const isFetchEnabled = !!(s3q.meta && s3q.meta.fetch)
+
+    const sqliteWhere = buildSqliteWhereClause(
+      s3q.criteria.where,
+      WLModel,
+      s3q.meta
+    )
+
+    const db = inputs.connection
+
+    try {
+      // Start a transaction
+      db.exec('BEGIN TRANSACTION')
+
+      let phRecords
+      if (isFetchEnabled) {
+        // Fetch matching records before deletion
+        const selectSql = `SELECT * FROM ${tableName} WHERE ${sqliteWhere}`
+        const selectStmt = db.prepare(selectSql)
+        phRecords = selectStmt.all()
+      }
+
+      // Perform the deletion
+      const deleteSql = `DELETE FROM ${tableName} WHERE ${sqliteWhere}`
+      const deleteStmt = db.prepare(deleteSql)
+      const deleteInfo = deleteStmt.run()
+
+      // Commit the transaction
+      db.exec('COMMIT')
+
+      if (!isFetchEnabled) {
+        return exits.success()
+      }
+
+      // Process fetched records
+      phRecords.forEach((phRecord) => {
+        processNativeRecord(phRecord, WLModel, s3q.meta)
+      })
+
+      return exits.success(phRecords)
+    } catch (err) {
+      // Rollback the transaction in case of error
+      db.exec('ROLLBACK')
+      return exits.error(err)
+    }
+  }
+}

package/lib/private/machines/drop-physical-model.js

@@ -0,0 +1,51 @@
+module.exports = {
+  friendlyName: 'Drop (physical model)',
+
+  description:
+    'Completely drop & destroy any traces of a particular physical model (i.e. SQLite table).',
+
+  sideEffects: 'idempotent',
+
+  inputs: {
+    connection: require('../constants/connection.input'),
+    tableName: require('../constants/table-name.input'),
+    meta: require('../constants/meta.input')
+  },
+
+  exits: {
+    success: {
+      description:
+        'If such a physical model exists, it was dropped successfully.'
+    }
+  },
+
+  fn: function (inputs, exits) {
+    // Get the SQLite database connection
+    const db = inputs.connection
+
+    try {
+      // SQL to drop the table
+      const dropTableSQL = `DROP TABLE IF EXISTS ${inputs.tableName}`
+
+      // Execute the drop table operation
+      db.prepare(dropTableSQL).run()
+
+      // SQL to remove the table's entry from sqlite_sequence (if it exists)
+      const cleanSequenceSQL = `DELETE FROM sqlite_sequence WHERE name = ?`
+
+      // Clean up the sqlite_sequence
+      db.prepare(cleanSequenceSQL).run(inputs.tableName)
+
+      // Return success, as the main operation (dropping the table) was successful
+      return exits.success()
+    } catch (error) {
+      if (error.message.includes('no such table: sqlite_sequence')) {
+        // If sqlite_sequence doesn't exist, it's not an error - just means no autoincrement was used
+        return exits.success()
+      }
+      return exits.error(
+        new Error(`Error dropping table ${inputs.tableName}: ${error.message}`)
+      )
+    }
+  }
+}

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.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
+    })
+  }
+}