sails-sqlite 0.0.0 → 0.2.0

package/lib/private/machines/private/reify-values-to-set.js

@@ -0,0 +1,83 @@
+const assert = require('assert')
+
+/**
+ * reifyValuesToSet()
+ *
+ * Prepare a dictionary of values to be used in a SQLite database operation.
+ * > The provided `valuesToSet` will be mutated in-place.
+ *
+ * @param {Object} valuesToSet
+ * @param {Object} WLModel
+ * @param {Object?} meta       [`meta` query key from the s3q]
+ */
+module.exports = function reifyValuesToSet(valuesToSet, WLModel, meta) {
+  assert(valuesToSet !== undefined, '1st argument is required')
+  assert(
+    typeof valuesToSet === 'object' &&
+      valuesToSet !== null &&
+      !Array.isArray(valuesToSet) &&
+      typeof valuesToSet !== 'function',
+    '1st argument must be a dictionary'
+  )
+  assert(WLModel !== undefined, '2nd argument is required')
+  assert(
+    typeof WLModel === 'object' &&
+      WLModel !== null &&
+      !Array.isArray(WLModel) &&
+      typeof WLModel !== 'function',
+    '2nd argument must be a WLModel, and it has to have a `definition` property for this utility to work.'
+  )
+
+  // Handle primary key safely
+  if (
+    WLModel.primaryKey &&
+    WLModel.attributes &&
+    WLModel.attributes[WLModel.primaryKey]
+  ) {
+    const primaryKeyAttrName = WLModel.primaryKey
+    const primaryKeyAttrDef = WLModel.attributes[WLModel.primaryKey]
+    const primaryKeyColumnName =
+      primaryKeyAttrDef.columnName || primaryKeyAttrName
+
+    if (valuesToSet[primaryKeyColumnName] === null) {
+      delete valuesToSet[primaryKeyColumnName]
+    } else if (valuesToSet[primaryKeyColumnName] !== undefined) {
+      // Ensure primary key is a number or string
+      if (
+        typeof valuesToSet[primaryKeyColumnName] !== 'number' &&
+        typeof valuesToSet[primaryKeyColumnName] !== 'string'
+      ) {
+        throw new Error(
+          `Invalid primary key value provided for \`${primaryKeyAttrName}\`. Must be a number or string.`
+        )
+      }
+    }
+  }
+
+  // Handle other attributes safely
+  if (WLModel.attributes && typeof WLModel.attributes === 'object') {
+    Object.entries(WLModel.attributes).forEach(([attrName, attrDef]) => {
+      if (!attrDef || typeof attrDef !== 'object') return
+
+      const columnName = attrDef.columnName || attrName
+      if (valuesToSet[columnName] === undefined) return
+
+      // Handle JSON type
+      if (attrDef.type === 'json' && valuesToSet[columnName] !== null) {
+        valuesToSet[columnName] = JSON.stringify(valuesToSet[columnName])
+      }
+
+      // Handle date type
+      if (attrDef.type === 'ref' && valuesToSet[columnName] instanceof Date) {
+        valuesToSet[columnName] = valuesToSet[columnName].toISOString()
+      }
+
+      // Handle boolean type
+      if (attrDef.type === 'boolean') {
+        valuesToSet[columnName] = valuesToSet[columnName] ? 1 : 0
+      }
+    })
+  }
+
+  return valuesToSet
+}

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

@@ -0,0 +1,70 @@
+module.exports = {
+  friendlyName: 'Release connection',
+
+  description: 'Release an active SQLite database connection.',
+
+  extendedDescription:
+    "For SQLite, this is typically a no-op as there is no connection pooling. However, it's included for consistency with other database adapters.",
+
+  sync: true,
+
+  inputs: {
+    connection: {
+      description: 'An active SQLite database connection.',
+      extendedDescription:
+        'The provided database connection instance must still be active. Only database connection instances created by the `getConnection()` function in this driver are supported.',
+      example: '===',
+      required: true
+    },
+
+    meta: {
+      friendlyName: 'Meta (custom)',
+      description: 'Additional stuff to pass to the driver.',
+      extendedDescription:
+        'This is reserved for custom driver-specific extensions. Please refer to the documentation for better-sqlite3 for more specific information.',
+      example: '==='
+    }
+  },
+
+  exits: {
+    success: {
+      description: 'The connection was released (no-op for SQLite).',
+      extendedDescription:
+        "For SQLite, this is typically a no-op, but it's included for consistency.",
+      outputFriendlyName: 'Report',
+      outputDescription:
+        'The `meta` property is reserved for custom driver-specific extensions.',
+      outputExample: '==='
+    },
+
+    badConnection: {
+      description: 'The provided connection is not a valid SQLite connection.',
+      extendedDescription:
+        'This might occur if the connection was already closed or if an invalid object was passed as the connection.',
+      outputFriendlyName: 'Report',
+      outputDescription:
+        'The `meta` property is reserved for custom driver-specific extensions.',
+      outputExample: '==='
+    }
+  },
+
+  fn: ({ connection, meta }, exits) => {
+    // Check if the connection is a valid SQLite database instance
+    if (
+      typeof connection !== 'object' ||
+      connection === null ||
+      typeof connection.close !== 'function'
+    ) {
+      return exits.badConnection({
+        meta
+      })
+    }
+
+    // For SQLite, releasing a connection is typically a no-op
+    // We don't actually close the connection here because SQLite connections
+    // are meant to be long-lived and are automatically closed when the database is closed
+    return exits.success({
+      meta
+    })
+  }
+}

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/set-physical-sequence.js

@@ -0,0 +1,77 @@
+module.exports = {
+  friendlyName: 'Set physical sequence',
+
+  description: 'Reset an auto-incrementing sequence to the specified value.',
+
+  sideEffects: 'idempotent',
+
+  inputs: {
+    connection: require('../constants/connection.input'),
+    sequenceName: { example: 'users', required: true },
+    sequenceValue: { example: 1, required: true },
+    meta: require('../constants/meta.input')
+  },
+
+  exits: {
+    success: {
+      description: 'The sequence was successfully reset.'
+    },
+    notFound: {
+      description: 'Could not find a sequence with the specified name.'
+    }
+  },
+
+  fn: function (inputs, exits) {
+    const db = inputs.connection
+    const sequenceName = inputs.sequenceName
+    const newSequenceValue = inputs.sequenceValue
+
+    // Parse the sequence name to get the actual table name
+    // PostgreSQL-style sequences are often named like 'user_id_seq', 'users_id_seq', etc.
+    // The table name should be the first string before the first underscore
+    let tableName = sequenceName
+
+    // Handle PostgreSQL-style sequence names
+    if (sequenceName.includes('_')) {
+      // Extract the table name as the first part before the first underscore
+      tableName = sequenceName.split('_')[0]
+    }
+
+    try {
+      // First, check if the table exists
+      const tableExists = db
+        .prepare(
+          "SELECT name FROM sqlite_master WHERE type='table' AND name = ?"
+        )
+        .get(tableName)
+
+      if (!tableExists) {
+        return exits.notFound(new Error(`Table '${tableName}' not found.`))
+      }
+
+      // If the table exists, update the sequence
+      const updateStmt = db.prepare(
+        'UPDATE sqlite_sequence SET seq = ? WHERE name = ?'
+      )
+      const updateResult = updateStmt.run(newSequenceValue - 1, tableName)
+
+      if (updateResult.changes === 0) {
+        // If no rows were updated, it means the table doesn't have an autoincrement column
+        // We'll insert a new row in this case
+        const insertStmt = db.prepare(
+          'INSERT INTO sqlite_sequence (name, seq) VALUES (?, ?)'
+        )
+        insertStmt.run(tableName, newSequenceValue - 1)
+      }
+
+      return exits.success()
+    } catch (error) {
+      // Handle the case where sqlite_sequence doesn't exist
+      if (error.message.includes('no such table: sqlite_sequence')) {
+        // This is not an error condition - it just means no tables with AUTOINCREMENT have been created yet
+        return exits.success()
+      }
+      return exits.error(error)
+    }
+  }
+}

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

@@ -0,0 +1,75 @@
+const buildSqliteWhereClause = require('./private/build-sqlite-where-clause')
+
+module.exports = {
+  friendlyName: 'Sum (records)',
+
+  description:
+    'Return the cumulative sum (∑) of a particular property over matching records.',
+
+  inputs: {
+    query: require('../constants/query.input'),
+    connection: require('../constants/connection.input'),
+    dryOrm: require('../constants/dry-orm.input')
+  },
+
+  exits: {
+    success: {
+      outputFriendlyName: 'Total (sum)',
+      outputDescription:
+        'The sum of the given property across all matching records.',
+      outputExample: 999.99
+    }
+  },
+
+  fn: function sum(inputs, exits) {
+    const s3q = inputs.query
+
+    const tableName = s3q.using
+    const numericFieldName = s3q.numericAttrName
+
+    // Grab the model definition
+    // 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.)`
+        )
+      )
+    }
+
+    // Build a SQLite WHERE clause from the `where` clause.
+    let whereClause
+    try {
+      whereClause = buildSqliteWhereClause(
+        s3q.criteria.where,
+        WLModel,
+        s3q.meta
+      )
+    } catch (e) {
+      return exits.error(e)
+    }
+
+    const db = inputs.connection
+
+    try {
+      let sumQuery = `SELECT COALESCE(SUM(\`${numericFieldName}\`), 0) as total FROM \`${tableName}\``
+      if (whereClause) {
+        sumQuery += ` WHERE ${whereClause}`
+      }
+
+      const stmt = db.prepare(sumQuery)
+      const result = stmt.get()
+
+      return exits.success(result.total)
+    } catch (err) {
+      return exits.error(err)
+    }
+  }
+}

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

@@ -0,0 +1,162 @@
+const util = require('util')
+const processNativeRecord = require('./private/process-native-record')
+const processNativeError = require('./private/process-native-error')
+const reifyValuesToSet = require('./private/reify-values-to-set')
+const buildSqliteWhereClause = require('./private/build-sqlite-where-clause')
+
+module.exports = {
+  friendlyName: 'Update (records)',
+
+  description:
+    'Update record(s) in the SQLite database based on 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 updated.',
+      outputExample: '==='
+    },
+    notUnique: require('../constants/not-unique.exit')
+  },
+
+  fn: async function (inputs, exits) {
+    const s3q = inputs.query
+    if (s3q.meta && s3q.meta.logSqliteS3Qs) {
+      console.log(
+        '* * * * * *\nADAPTER (UPDATE 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)
+
+    try {
+      reifyValuesToSet(s3q.valuesToSet, WLModel, s3q.meta)
+    } catch (e) {
+      return exits.error(e)
+    }
+
+    const sqliteWhere = buildSqliteWhereClause(
+      s3q.criteria.where,
+      WLModel,
+      s3q.meta
+    )
+
+    const db = inputs.connection
+
+    // Check if we're already in a transaction
+    const wasInTransaction = db.inTransaction
+
+    try {
+      // 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 = 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}\` = ?`)
+        .join(', ')
+      const updateSql = sqliteWhere
+        ? `UPDATE \`${tableName}\` SET ${setClauses} WHERE ${sqliteWhere}`
+        : `UPDATE \`${tableName}\` SET ${setClauses}`
+      const updateStmt = db.prepare(updateSql)
+
+      // Execute the UPDATE
+      const updateInfo = updateStmt.run(...Object.values(s3q.valuesToSet))
+
+      // Handle case where pk value was changed
+      if (
+        s3q.valuesToSet[pkColumnName] !== undefined &&
+        affectedIds.length === 1
+      ) {
+        const oldPkValue = affectedIds[0]
+        const newPkValue = s3q.valuesToSet[pkColumnName]
+        affectedIds = [newPkValue]
+      } else if (
+        s3q.valuesToSet[pkColumnName] !== undefined &&
+        affectedIds.length > 1
+      ) {
+        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!)'
+          )
+        )
+      }
+
+      // If fetch is not enabled, we're done
+      if (!isFetchEnabled) {
+        if (!wasInTransaction) {
+          db.exec('COMMIT')
+        }
+        return exits.success()
+      }
+
+      // Fetch the updated records
+      const fetchSql = `SELECT * FROM \`${tableName}\` WHERE \`${pkColumnName}\` IN (${affectedIds.map(() => '?').join(', ')})`
+      const fetchStmt = db.prepare(fetchSql)
+      const phRecords = fetchStmt.all(affectedIds)
+
+      // Process records
+      phRecords.forEach((phRecord) => {
+        processNativeRecord(phRecord, WLModel, s3q.meta)
+      })
+
+      if (!wasInTransaction) {
+        db.exec('COMMIT')
+      }
+      return exits.success(phRecords)
+    } catch (err) {
+      if (!wasInTransaction) {
+        db.exec('ROLLBACK')
+      }
+      err = processNativeError(err)
+      if (err.footprint && err.footprint.identity === 'notUnique') {
+        return exits.notUnique(err)
+      }
+      return exits.error(err)
+    }
+  }
+}

package/lib/private/machines/verify-model-def.js

@@ -0,0 +1,38 @@
+module.exports = {
+  friendlyName: 'Verify model def',
+
+  description:
+    'Verify that the specified model definition is compatible with this adapter.',
+
+  extendedDescription:
+    'This assumes that the provided model def has already undergone adapter-agnostic normalization, and is considered generally valid.',
+
+  sideEffects: 'cacheable',
+
+  sync: true,
+
+  inputs: {
+    modelDef: {
+      description: 'A Waterline model definition.',
+      extendedDescription:
+        'This model definition should already be fully-formed (i.e. it should have undergone generic normalization/validation already).',
+      moreInfoUrl:
+        'http://sailsjs.com/documentation/concepts/models-and-orm/models',
+      example: '===', // {}
+      readOnly: true,
+      required: true
+    }
+  },
+
+  exits: {
+    invalid: {
+      description: 'The provided model definition was invalid.',
+      outputFriendlyName: 'Error',
+      outputExample: '===' // e.g. new Error('Primary key attribute should have `columnName: \'_id\'`.')
+    }
+  },
+
+  fn: function (inputs, exits) {
+    return exits.success()
+  }
+}

package/package.json

@@ -1,14 +1,39 @@
 {
   "name": "sails-sqlite",
-  "version": "0.0.0",
+  "version": "0.2.0",
   "description": "SQLite adapter for Sails/Waterline",
-  "main": "./lib",
+  "main": "lib",
+  "directories": {
+    "lib": "./lib"
+  },
   "scripts": {
-    "test": "npm run lint && npm run custom-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"
   },
   "repository": {
     "type": "git",
-    "url": "github.com/sailscastshq/sails-sqlite"
+    "url": "git://github.com/sailscastshq/sails-sqlite.git"
+  },
+  "bugs": "https://github.com/sailscastshq/sails-sqlite/issues",
+  "waterlineAdapter": {
+    "waterlineVersion": "~0.13.0",
+    "interfaces": [
+      "semantic",
+      "queryable",
+      "migratable",
+      "associations",
+      "sql"
+    ],
+    "features": [
+      "crossAdapter",
+      "unique",
+      "autoIncrement",
+      "schemas"
+    ]
   },
   "keywords": [
     "sqlite",
@@ -21,5 +46,33 @@
     "database-adapter"
   ],
   "author": "Kelvin Omereshone <kelvin@sailscasts.com>",
-  "license": "MIT"
+  "license": "MIT",
+  "devDependencies": {
+    "husky": "^9.0.11",
+    "lint-staged": "^15.2.2",
+    "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"
+  },
+  "machinepack": {
+    "friendlyName": "SQLite",
+    "extendedDescription": "Uses the Node.js better-sqlite3 driver located at https://npmjs.com/package/better-sqlite3",
+    "moreInfoUrl": "https://github.com/WiseLibs/better-sqlite3",
+    "implements": [
+      "connectable",
+      "modeled",
+      "migratable"
+    ],
+    "machineDir": "lib/private/machines/",
+    "exportStyle": "dryDictionary"
+  }
 }