sails-sqlite 0.1.0 → 0.2.0

package/package.json

@@ -1,13 +1,15 @@
 {
   "name": "sails-sqlite",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "SQLite adapter for Sails/Waterline",
   "main": "lib",
   "directories": {
     "lib": "./lib"
   },
   "scripts": {
-    "test": "node tests/",
+    "test": "npm run lint && npm run custom-tests && npm run adapter-tests",
+    "custom-tests": "node tests/",
+    "adapter-tests": "rm -rf .tmp && node tests/runner.js",
     "lint": "prettier --check .",
     "lint:fix": "prettier --write .",
     "prepare": "husky"
@@ -48,13 +50,16 @@
   "devDependencies": {
     "husky": "^9.0.11",
     "lint-staged": "^15.2.2",
-    "prettier": "3.2.5"
+    "mocha": "^11.7.2",
+    "prettier": "3.2.5",
+    "waterline-adapter-tests": "^1.0.1"
   },
   "lint-staged": {
     "**/*": "prettier --write --ignore-unknown"
   },
   "dependencies": {
     "better-sqlite3": "^12.2.0",
+    "flaverr": "^1.10.0",
     "machine": "^15.2.3",
     "waterline-utils": "^1.4.5"
   },

package/tests/index.js

@@ -6,7 +6,7 @@ const fs = require('node:fs')
 
 // __dirname is automatically available in CommonJS
 
-const testFiles = ['adapter.test.js', 'sequence.test.js', 'datatypes.test.js']
+const testFiles = ['transaction.test.js']
 
 function cleanupTestDatabases() {
   try {

package/tests/runner.js

@@ -0,0 +1,99 @@
+/**
+ * Run integration tests
+ *
+ * Uses the `waterline-adapter-tests` module to
+ * run mocha tests against the appropriate version
+ * of Waterline.  Only the interfaces explicitly
+ * declared in this adapter's `package.json` file
+ * are tested. (e.g. `queryable`, `semantic`, etc.)
+ */
+
+/**
+ * Module dependencies
+ */
+
+var util = require('util')
+var TestRunner = require('waterline-adapter-tests')
+var Adapter = require('../')
+
+// Grab targeted interfaces from this adapter's `package.json` file:
+var package = {}
+var interfaces = []
+var features = []
+try {
+  package = require('../package.json')
+  interfaces = package.waterlineAdapter.interfaces
+  features = package.waterlineAdapter.features
+} catch (e) {
+  throw new Error(
+    '\n' +
+      'Could not read supported interfaces from `waterlineAdapter.interfaces`' +
+      '\n' +
+      "in this adapter's `package.json` file ::" +
+      '\n' +
+      util.inspect(e)
+  )
+}
+
+console.log('Testing `' + package.name + '`, a Sails/Waterline adapter.')
+console.log(
+  'Running `waterline-adapter-tests` against ' +
+    interfaces.length +
+    ' interfaces...'
+)
+console.log('( ' + interfaces.join(', ') + ' )')
+console.log()
+console.log('Latest draft of Waterline adapter interface spec:')
+console.log(
+  'http://sailsjs.com/documentation/concepts/extending-sails/adapters'
+)
+console.log()
+
+/**
+ * Integration Test Runner
+ *
+ * Uses the `waterline-adapter-tests` module to
+ * run mocha tests against the specified interfaces
+ * of the currently-implemented Waterline adapter API.
+ */
+new TestRunner({
+  // Mocha opts
+  mocha: {
+    bail: true
+  },
+
+  // Load the adapter module.
+  adapter: Adapter,
+
+  // Default connection config to use.
+  config: {
+    url: '.tmp/test-db.sqlite',
+    schema: false
+  },
+
+  // The set of adapter interfaces to test against.
+  // (grabbed these from this adapter's package.json file above)
+  interfaces: interfaces,
+
+  // The set of adapter features to test against.
+  // (grabbed these from this adapter's package.json file above)
+  features: features
+
+  // Most databases implement 'semantic' and 'queryable'.
+  //
+  // As of Sails/Waterline v0.10, the 'associations' interface
+  // is also available.  If you don't implement 'associations',
+  // it will be polyfilled for you by Waterline core.  The core
+  // implementation will always be used for cross-adapter / cross-connection
+  // joins.
+  //
+  // In future versions of Sails/Waterline, 'queryable' may be also
+  // be polyfilled by core.
+  //
+  // These polyfilled implementations can usually be further optimized at the
+  // adapter level, since most databases provide optimizations for internal
+  // operations.
+  //
+  // Full interface reference:
+  // https://github.com/balderdashy/sails-docs/blob/master/adapter-specification.md
+})

package/tests/transaction.test.js

@@ -0,0 +1,562 @@
+const { test, describe, before, after, beforeEach } = require('node:test')
+const assert = require('node:assert')
+const path = require('node:path')
+const fs = require('node:fs')
+
+// Import the adapter
+const adapter = require('../lib/index.js')
+
+describe('Transaction support', () => {
+  let testDbPath
+  let datastore
+  let models
+
+  before(async () => {
+    testDbPath = path.join(__dirname, `test-transaction-${Date.now()}.sqlite`)
+    datastore = {
+      identity: 'testDatastore',
+      adapter: 'sails-sqlite',
+      url: testDbPath
+    }
+
+    models = {
+      user: {
+        identity: 'user',
+        tableName: 'users',
+        primaryKey: 'id',
+        definition: {
+          id: {
+            type: 'number',
+            autoIncrement: true,
+            columnName: 'id'
+          },
+          name: {
+            type: 'string',
+            required: true,
+            columnName: 'name'
+          },
+          email: {
+            type: 'string',
+            required: true,
+            unique: true,
+            columnName: 'email'
+          },
+          balance: {
+            type: 'number',
+            defaultsTo: 0,
+            columnName: 'balance'
+          }
+        }
+      }
+    }
+
+    // Register datastore
+    await new Promise((resolve, reject) => {
+      adapter.registerDatastore(datastore, models, (err) => {
+        if (err) return reject(err)
+        resolve()
+      })
+    })
+
+    // Create table schema
+    const tableDef = {
+      id: {
+        type: 'number',
+        primaryKey: true,
+        autoIncrement: true,
+        required: true
+      },
+      name: {
+        type: 'string',
+        required: true
+      },
+      email: {
+        type: 'string',
+        required: true,
+        unique: true
+      },
+      balance: {
+        type: 'number',
+        defaultsTo: 0
+      }
+    }
+
+    await new Promise((resolve, reject) => {
+      adapter.define('testDatastore', 'users', tableDef, (err) => {
+        if (err) return reject(err)
+        resolve()
+      })
+    })
+  })
+
+  after(async () => {
+    // Teardown datastore
+    await new Promise((resolve, reject) => {
+      adapter.teardown('testDatastore', (err) => {
+        if (err) return reject(err)
+        resolve()
+      })
+    })
+
+    // Clean up test database
+    if (fs.existsSync(testDbPath)) {
+      try {
+        fs.unlinkSync(testDbPath)
+      } catch (err) {
+        // Ignore cleanup errors
+      }
+    }
+  })
+
+  beforeEach(async () => {
+    // Clean up any existing data and reset transaction state before each test
+    try {
+      // First, make sure any active transactions are rolled back
+      const connection = await new Promise((resolve, reject) => {
+        adapter.leaseConnection('testDatastore', {}, (err, connection) => {
+          if (err) return reject(err)
+          resolve(connection)
+        })
+      })
+
+      if (connection && connection.inTransaction) {
+        await new Promise((resolve, reject) => {
+          adapter.rollbackTransaction(
+            'testDatastore',
+            { connection, meta: {} },
+            (err) => {
+              if (err) return reject(err)
+              resolve()
+            }
+          )
+        })
+      }
+
+      // Clean up existing data
+      const findQuery = {
+        using: 'users',
+        criteria: {}
+      }
+
+      const existingRecords = await new Promise((resolve, reject) => {
+        adapter.find('testDatastore', findQuery, (err, result) => {
+          if (err) return reject(err)
+          resolve(result || [])
+        })
+      })
+
+      if (existingRecords.length > 0) {
+        // Delete each record by its primary key
+        for (const record of existingRecords) {
+          const deleteQuery = {
+            using: 'users',
+            criteria: { id: record.id }
+          }
+
+          await new Promise((resolve, reject) => {
+            adapter.destroy('testDatastore', deleteQuery, (err) => {
+              if (err) return reject(err)
+              resolve()
+            })
+          })
+        }
+      }
+    } catch (err) {
+      // Ignore cleanup errors in beforeEach
+    }
+  })
+
+  describe('leaseConnection', () => {
+    test('should lease a connection successfully', async () => {
+      const connection = await new Promise((resolve, reject) => {
+        adapter.leaseConnection('testDatastore', {}, (err, connection) => {
+          if (err) return reject(err)
+          resolve(connection)
+        })
+      })
+
+      assert(connection, 'Connection should be returned')
+      assert(
+        typeof connection.inTransaction !== 'undefined',
+        'Connection should be a database instance'
+      )
+    })
+
+    test('should fail with invalid datastore name', async () => {
+      try {
+        await new Promise((resolve, reject) => {
+          adapter.leaseConnection('invalidDatastore', {}, (err, connection) => {
+            if (err) return reject(err)
+            resolve(connection)
+          })
+        })
+        assert.fail('Should have thrown an error')
+      } catch (err) {
+        assert(
+          err.message.includes('no matching datastore entry'),
+          'Should have proper error message'
+        )
+      }
+    })
+  })
+
+  describe('beginTransaction', () => {
+    test('should begin transaction successfully', async () => {
+      const connection = await new Promise((resolve, reject) => {
+        adapter.leaseConnection('testDatastore', {}, (err, connection) => {
+          if (err) return reject(err)
+          resolve(connection)
+        })
+      })
+
+      await new Promise((resolve, reject) => {
+        adapter.beginTransaction(
+          'testDatastore',
+          { connection, meta: {} },
+          (err) => {
+            if (err) return reject(err)
+            resolve()
+          }
+        )
+      })
+
+      // Verify transaction is active
+      assert(connection.inTransaction, 'Transaction should be active')
+    })
+
+    test('should fail to begin nested transaction', async () => {
+      const connection = await new Promise((resolve, reject) => {
+        adapter.leaseConnection('testDatastore', {}, (err, connection) => {
+          if (err) return reject(err)
+          resolve(connection)
+        })
+      })
+
+      // Begin first transaction
+      await new Promise((resolve, reject) => {
+        adapter.beginTransaction(
+          'testDatastore',
+          { connection, meta: {} },
+          (err) => {
+            if (err) return reject(err)
+            resolve()
+          }
+        )
+      })
+
+      // Try to begin second transaction (should fail)
+      try {
+        await new Promise((resolve, reject) => {
+          adapter.beginTransaction(
+            'testDatastore',
+            { connection, meta: {} },
+            (err) => {
+              if (err) return reject(err)
+              resolve()
+            }
+          )
+        })
+        assert.fail('Should have thrown an error for nested transaction')
+      } catch (err) {
+        assert(
+          err.message.includes('Transaction is already active'),
+          'Should have proper error message'
+        )
+      }
+    })
+  })
+
+  describe('commitTransaction', () => {
+    test('should commit transaction and persist changes', async () => {
+      const connection = await new Promise((resolve, reject) => {
+        adapter.leaseConnection('testDatastore', {}, (err, connection) => {
+          if (err) return reject(err)
+          resolve(connection)
+        })
+      })
+
+      // Begin transaction
+      await new Promise((resolve, reject) => {
+        adapter.beginTransaction(
+          'testDatastore',
+          { connection, meta: {} },
+          (err) => {
+            if (err) return reject(err)
+            resolve()
+          }
+        )
+      })
+
+      // Create a record within transaction
+      const createQuery = {
+        using: 'users',
+        newRecord: {
+          name: 'Transaction User',
+          email: 'tx@example.com',
+          balance: 100
+        },
+        meta: { fetch: true }
+      }
+
+      const createdRecord = await new Promise((resolve, reject) => {
+        adapter.create('testDatastore', createQuery, (err, result) => {
+          if (err) return reject(err)
+          resolve(result)
+        })
+      })
+
+      assert(createdRecord, 'Record should be created')
+      assert(connection.inTransaction, 'Transaction should still be active')
+
+      // Commit transaction
+      await new Promise((resolve, reject) => {
+        adapter.commitTransaction(
+          'testDatastore',
+          { connection, meta: {} },
+          (err) => {
+            if (err) return reject(err)
+            resolve()
+          }
+        )
+      })
+
+      assert(!connection.inTransaction, 'Transaction should be committed')
+
+      // Verify the record persists after commit
+      const findQuery = {
+        using: 'users',
+        criteria: { email: 'tx@example.com' }
+      }
+
+      const foundRecords = await new Promise((resolve, reject) => {
+        adapter.find('testDatastore', findQuery, (err, result) => {
+          if (err) return reject(err)
+          resolve(result)
+        })
+      })
+
+      assert(foundRecords.length === 1, 'Record should persist after commit')
+      assert.equal(foundRecords[0].name, 'Transaction User')
+    })
+
+    test('should fail to commit when no active transaction', async () => {
+      const connection = await new Promise((resolve, reject) => {
+        adapter.leaseConnection('testDatastore', {}, (err, connection) => {
+          if (err) return reject(err)
+          resolve(connection)
+        })
+      })
+
+      try {
+        await new Promise((resolve, reject) => {
+          adapter.commitTransaction(
+            'testDatastore',
+            { connection, meta: {} },
+            (err) => {
+              if (err) return reject(err)
+              resolve()
+            }
+          )
+        })
+        assert.fail('Should have thrown an error')
+      } catch (err) {
+        assert(
+          err.message.includes('No active transaction'),
+          'Should have proper error message'
+        )
+      }
+    })
+  })
+
+  describe('rollbackTransaction', () => {
+    test('should rollback transaction and discard changes', async () => {
+      const connection = await new Promise((resolve, reject) => {
+        adapter.leaseConnection('testDatastore', {}, (err, connection) => {
+          if (err) return reject(err)
+          resolve(connection)
+        })
+      })
+
+      // Begin transaction
+      await new Promise((resolve, reject) => {
+        adapter.beginTransaction(
+          'testDatastore',
+          { connection, meta: {} },
+          (err) => {
+            if (err) return reject(err)
+            resolve()
+          }
+        )
+      })
+
+      // Create a record within transaction
+      const createQuery = {
+        using: 'users',
+        newRecord: {
+          name: 'Rollback User',
+          email: 'rollback@example.com',
+          balance: 500
+        },
+        meta: { fetch: true }
+      }
+
+      const createdRecord = await new Promise((resolve, reject) => {
+        adapter.create('testDatastore', createQuery, (err, result) => {
+          if (err) return reject(err)
+          resolve(result)
+        })
+      })
+
+      assert(createdRecord, 'Record should be created')
+      assert(connection.inTransaction, 'Transaction should be active')
+
+      // Rollback transaction
+      await new Promise((resolve, reject) => {
+        adapter.rollbackTransaction(
+          'testDatastore',
+          { connection, meta: {} },
+          (err) => {
+            if (err) return reject(err)
+            resolve()
+          }
+        )
+      })
+
+      assert(!connection.inTransaction, 'Transaction should be rolled back')
+
+      // Verify the record does NOT persist after rollback
+      const findQuery = {
+        using: 'users',
+        criteria: { email: 'rollback@example.com' }
+      }
+
+      const foundRecords = await new Promise((resolve, reject) => {
+        adapter.find('testDatastore', findQuery, (err, result) => {
+          if (err) return reject(err)
+          resolve(result)
+        })
+      })
+
+      assert(
+        foundRecords.length === 0,
+        'Record should NOT persist after rollback'
+      )
+    })
+
+    test('should fail to rollback when no active transaction', async () => {
+      const connection = await new Promise((resolve, reject) => {
+        adapter.leaseConnection('testDatastore', {}, (err, connection) => {
+          if (err) return reject(err)
+          resolve(connection)
+        })
+      })
+
+      try {
+        await new Promise((resolve, reject) => {
+          adapter.rollbackTransaction(
+            'testDatastore',
+            { connection, meta: {} },
+            (err) => {
+              if (err) return reject(err)
+              resolve()
+            }
+          )
+        })
+        assert.fail('Should have thrown an error')
+      } catch (err) {
+        assert(
+          err.message.includes('No active transaction'),
+          'Should have proper error message'
+        )
+      }
+    })
+  })
+
+  describe('Transaction isolation', () => {
+    test('should maintain transaction isolation', async () => {
+      // Create initial record
+      const initialQuery = {
+        using: 'users',
+        newRecord: {
+          name: 'Initial User',
+          email: 'initial@example.com',
+          balance: 1000
+        },
+        meta: { fetch: true }
+      }
+
+      await new Promise((resolve, reject) => {
+        adapter.create('testDatastore', initialQuery, (err, result) => {
+          if (err) return reject(err)
+          resolve(result)
+        })
+      })
+
+      const connection = await new Promise((resolve, reject) => {
+        adapter.leaseConnection('testDatastore', {}, (err, connection) => {
+          if (err) return reject(err)
+          resolve(connection)
+        })
+      })
+
+      // Begin transaction
+      await new Promise((resolve, reject) => {
+        adapter.beginTransaction(
+          'testDatastore',
+          { connection, meta: {} },
+          (err) => {
+            if (err) return reject(err)
+            resolve()
+          }
+        )
+      })
+
+      // Update record within transaction
+      const updateQuery = {
+        using: 'users',
+        criteria: { email: 'initial@example.com' },
+        valuesToSet: { balance: 500 },
+        meta: { fetch: true }
+      }
+
+      await new Promise((resolve, reject) => {
+        adapter.update('testDatastore', updateQuery, (err, result) => {
+          if (err) return reject(err)
+          resolve(result)
+        })
+      })
+
+      // Rollback the transaction
+      await new Promise((resolve, reject) => {
+        adapter.rollbackTransaction(
+          'testDatastore',
+          { connection, meta: {} },
+          (err) => {
+            if (err) return reject(err)
+            resolve()
+          }
+        )
+      })
+
+      // Verify original value is restored
+      const findQuery = {
+        using: 'users',
+        criteria: { email: 'initial@example.com' }
+      }
+
+      const foundRecords = await new Promise((resolve, reject) => {
+        adapter.find('testDatastore', findQuery, (err, result) => {
+          if (err) return reject(err)
+          resolve(result)
+        })
+      })
+
+      assert(foundRecords.length === 1, 'Record should exist')
+      assert.equal(
+        foundRecords[0].balance,
+        1000,
+        'Original balance should be restored'
+      )
+    })
+  })
+})