sails-sqlite 0.2.0 → 0.2.2

package/lib/index.js

@@ -19,6 +19,10 @@ const DRY_MACHINES = {
   dropPhysicalModel: require('./private/machines/drop-physical-model'),
   setPhysicalSequence: require('./private/machines/set-physical-sequence'),
   join: require('./private/machines/join'),
+  sendNativeQuery: require('./private/machines/send-native-query'),
+  compileStatement: require('./private/machines/compile-statement'),
+  parseNativeQueryResult: require('./private/machines/parse-native-query-result'),
+  parseNativeQueryError: require('./private/machines/parse-native-query-error'),
   beginTransaction: require('./private/machines/begin-transaction'),
   commitTransaction: require('./private/machines/commit-transaction'),
   rollbackTransaction: require('./private/machines/rollback-transaction'),
@@ -88,7 +92,7 @@ module.exports = {
   // Default configuration for connections
   defaults: {
     schema: false,
-    url: 'db/data.db',
+    url: 'db/local.db',
     pragmas: {
       journal_mode: 'WAL'
     }
@@ -233,6 +237,13 @@ module.exports = {
               destroyManager: WET_MACHINES.destroyManager,
               getConnection: WET_MACHINES.getConnection,
               releaseConnection: WET_MACHINES.releaseConnection,
+              sendNativeQuery: WET_MACHINES.sendNativeQuery,
+              compileStatement: WET_MACHINES.compileStatement,
+              parseNativeQueryResult: WET_MACHINES.parseNativeQueryResult,
+              parseNativeQueryError: WET_MACHINES.parseNativeQueryError,
+              beginTransaction: WET_MACHINES.beginTransaction,
+              commitTransaction: WET_MACHINES.commitTransaction,
+              rollbackTransaction: WET_MACHINES.rollbackTransaction,
               Database
             }
           }

package/lib/private/machines/compile-statement.js

@@ -0,0 +1,62 @@
+const compileStatementUtil = require('./private/compile-statement')
+
+module.exports = {
+  friendlyName: 'Compile statement',
+
+  description: 'Compile a Waterline statement to a native query for SQLite.',
+
+  inputs: {
+    statement: {
+      description:
+        'A Waterline statement (stage 4 query) to compile into a native query.',
+      extendedDescription:
+        'See documentation for info on Waterline statements.',
+      example: '===',
+      required: true
+    },
+
+    meta: {
+      friendlyName: 'Meta (custom)',
+      description: 'Additional stuff to pass to the driver.',
+      extendedDescription:
+        'This is reserved for custom driver-specific extensions.',
+      example: '==='
+    }
+  },
+
+  exits: {
+    success: {
+      description:
+        'The provided Waterline statement was compiled successfully.',
+      outputVariableName: 'report',
+      outputDescription:
+        'The `nativeQuery` property is the compiled native query for the database. The `valuesToEscape` property is an array of strings, numbers, or special literals (true, false, or null) to escape and include in the query, in order. The `meta` property is reserved for custom driver-specific extensions.',
+      outputExample: '==='
+    },
+
+    malformed: {
+      description: 'The provided Waterline statement could not be compiled.',
+      outputVariableName: 'report',
+      outputDescription:
+        'The `error` property is a JavaScript Error instance with more details about what went wrong. The `meta` property is reserved for custom driver-specific extensions.',
+      outputExample: '==='
+    }
+  },
+
+  fn: function compileStatement(inputs, exits) {
+    try {
+      const compiled = compileStatementUtil(inputs.statement)
+
+      return exits.success({
+        nativeQuery: compiled.sql,
+        valuesToEscape: compiled.bindings || [],
+        meta: inputs.meta
+      })
+    } catch (err) {
+      return exits.malformed({
+        error: err,
+        meta: inputs.meta
+      })
+    }
+  }
+}

package/lib/private/machines/parse-native-query-error.js

@@ -0,0 +1,90 @@
+module.exports = {
+  friendlyName: 'Parse native query error',
+
+  description:
+    'Attempt to identify and parse a raw error from sending a native query and normalize it into a standard error footprint.',
+
+  inputs: {
+    nativeQueryError: {
+      description:
+        'The error sent back from the database as a result of a native query.',
+      extendedDescription:
+        'Specifically, this is the Error returned from sendNativeQuery().',
+      example: '===',
+      required: true
+    },
+
+    meta: {
+      friendlyName: 'Meta (custom)',
+      description: 'Additional stuff to pass to the driver.',
+      extendedDescription:
+        'This is reserved for custom driver-specific extensions.',
+      example: '==='
+    }
+  },
+
+  exits: {
+    success: {
+      description: 'The error was parsed successfully.',
+      outputVariableName: 'report',
+      outputDescription:
+        'The `footprint` property is the normalized "footprint" dictionary representing the provided error.',
+      outputExample: '==='
+    },
+
+    malformed: {
+      description:
+        'The provided error cannot be parsed (perhaps it was corrupted or otherwise incomplete).',
+      outputVariableName: 'report',
+      outputDescription:
+        'The `error` property is a JavaScript Error instance with more details about what went wrong. The `meta` property is reserved for custom driver-specific extensions.',
+      outputExample: '==='
+    },
+
+    notUnique: {
+      description: 'A uniqueness constraint was violated.',
+      outputVariableName: 'report',
+      outputDescription:
+        'The `footprint` property contains details about the uniqueness error.',
+      outputExample: '==='
+    },
+
+    notFound: {
+      description: 'No record(s) found matching the specified criteria.',
+      outputVariableName: 'report',
+      outputDescription:
+        'The `footprint` property contains details about the not found error.',
+      outputExample: '==='
+    }
+  },
+
+  fn: function parseNativeQueryError(inputs, exits) {
+    try {
+      const err = inputs.nativeQueryError
+      const footprint = {
+        identity: 'unknown',
+        error: err,
+        raw: err
+      }
+
+      if (err.code === 'SQLITE_CONSTRAINT') {
+        if (err.message && err.message.includes('UNIQUE')) {
+          return exits.notUnique({
+            footprint: footprint,
+            meta: inputs.meta
+          })
+        }
+      }
+
+      return exits.success({
+        footprint: footprint,
+        meta: inputs.meta
+      })
+    } catch (err) {
+      return exits.malformed({
+        error: err,
+        meta: inputs.meta
+      })
+    }
+  }
+}

package/lib/private/machines/parse-native-query-result.js

@@ -0,0 +1,59 @@
+module.exports = {
+  friendlyName: 'Parse native query result',
+
+  description: 'Parse a raw result from a native query and normalize it.',
+
+  inputs: {
+    nativeQueryResult: {
+      description:
+        'The result data sent back from the the database as a result of a native query.',
+      extendedDescription:
+        'Specifically, this is the `result` returned by sendNativeQuery().',
+      example: '===',
+      required: true
+    },
+
+    meta: {
+      friendlyName: 'Meta (custom)',
+      description: 'Additional stuff to pass to the driver.',
+      extendedDescription:
+        'This is reserved for custom driver-specific extensions.',
+      example: '==='
+    }
+  },
+
+  exits: {
+    success: {
+      description: 'The result was parsed successfully.',
+      outputVariableName: 'report',
+      outputDescription:
+        'The `result` property is the parsed result. The `meta` property is reserved for custom driver-specific extensions.',
+      outputExample: '==='
+    },
+
+    couldNotParse: {
+      description:
+        'The provided result could not be parsed (it might be corrupted or in an unexpected format).',
+      outputVariableName: 'report',
+      outputDescription:
+        'The `error` property is a JavaScript Error instance with more details about what went wrong. The `meta` property is reserved for custom driver-specific extensions.',
+      outputExample: '==='
+    }
+  },
+
+  fn: function parseNativeQueryResult(inputs, exits) {
+    try {
+      const result = inputs.nativeQueryResult
+
+      return exits.success({
+        result: result.rows || [],
+        meta: inputs.meta
+      })
+    } catch (err) {
+      return exits.couldNotParse({
+        error: err,
+        meta: inputs.meta
+      })
+    }
+  }
+}

package/lib/private/machines/private/compile-statement.js

@@ -43,12 +43,26 @@ module.exports = function compileStatement(statement) {
     ) {
       const orderClauses = globalOrderBy.map((orderItem) => {
         if (typeof orderItem === 'string') {
+          if (orderItem.includes('.')) {
+            const parts = orderItem.split('.')
+            if (parts.length === 2) {
+              const [tableName, columnName] = parts
+              return `\`${tableName}\`.\`${columnName}\` ASC`
+            }
+          }
           return `\`${orderItem}\` ASC`
         }
         if (typeof orderItem === 'object') {
           const key = Object.keys(orderItem)[0]
           const direction =
             orderItem[key].toUpperCase() === 'DESC' ? 'DESC' : 'ASC'
+          if (key.includes('.')) {
+            const parts = key.split('.')
+            if (parts.length === 2) {
+              const [tableName, columnName] = parts
+              return `\`${tableName}\`.\`${columnName}\` ${direction}`
+            }
+          }
           return `\`${key}\` ${direction}`
         }
         return orderItem
@@ -61,6 +75,18 @@ module.exports = function compileStatement(statement) {
 
   // Handle regular SELECT statements
   if (statement.select) {
+    // Determine parent table for ORDER BY disambiguation
+    let parentTable = null
+    if (statement.from) {
+      if (statement.from.includes(' as ')) {
+        parentTable = statement.from.split(' as ')[0].trim()
+      } else {
+        parentTable = statement.from
+      }
+    }
+    const hasJoins =
+      statement.leftOuterJoin && statement.leftOuterJoin.length > 0
+
     // SELECT clause
     if (Array.isArray(statement.select) && statement.select.length > 0) {
       const selectColumns = statement.select.map((col) => {
@@ -168,12 +194,34 @@ module.exports = function compileStatement(statement) {
     ) {
       const orderClauses = statement.orderBy.map((orderItem) => {
         if (typeof orderItem === 'string') {
+          if (orderItem.includes('.')) {
+            const parts = orderItem.split('.')
+            if (parts.length === 2) {
+              const [tableName, columnName] = parts
+              return `\`${tableName}\`.\`${columnName}\` ASC`
+            }
+          }
+          // If there are JOINs and column is unqualified, prefix with parent table
+          if (hasJoins && parentTable) {
+            return `\`${parentTable}\`.\`${orderItem}\` ASC`
+          }
           return `\`${orderItem}\` ASC`
         }
         if (typeof orderItem === 'object') {
           const key = Object.keys(orderItem)[0]
           const direction =
             orderItem[key].toUpperCase() === 'DESC' ? 'DESC' : 'ASC'
+          if (key.includes('.')) {
+            const parts = key.split('.')
+            if (parts.length === 2) {
+              const [tableName, columnName] = parts
+              return `\`${tableName}\`.\`${columnName}\` ${direction}`
+            }
+          }
+          // If there are JOINs and column is unqualified, prefix with parent table
+          if (hasJoins && parentTable) {
+            return `\`${parentTable}\`.\`${key}\` ${direction}`
+          }
           return `\`${key}\` ${direction}`
         }
         return orderItem

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

@@ -55,6 +55,11 @@ module.exports = function processEachRecord(options) {
       _.each(WLModel.definition, (attrDef, attrName) => {
         const columnName = attrDef.columnName || attrName
 
+        // Skip processing if this is a populated association (it's already an object/array)
+        if (attrDef.collection || attrDef.model) {
+          return
+        }
+
         if (columnName in record) {
           switch (attrDef.type) {
             case 'boolean':
@@ -66,7 +71,10 @@ module.exports = function processEachRecord(options) {
 
             case 'json':
               // SQLite stores JSON as text, so we need to parse it
-              if (record[columnName] !== null) {
+              if (
+                record[columnName] !== null &&
+                typeof record[columnName] === 'string'
+              ) {
                 try {
                   record[columnName] = JSON.parse(record[columnName])
                 } catch (e) {
@@ -80,7 +88,9 @@ module.exports = function processEachRecord(options) {
 
             case 'number':
               // Ensure numbers are actually numbers
-              record[columnName] = Number(record[columnName])
+              if (typeof record[columnName] !== 'number') {
+                record[columnName] = Number(record[columnName])
+              }
               break
 
             case 'date':

package/lib/private/machines/send-native-query.js

@@ -0,0 +1,100 @@
+module.exports = {
+  friendlyName: 'Send native query',
+
+  description: 'Send a native query to the SQLite database.',
+
+  inputs: {
+    connection: {
+      friendlyName: 'Connection',
+      description: 'An active database connection.',
+      extendedDescription:
+        'The provided database connection instance must still be active. Only database connection instances created by the `getConnection()` machine in this driver are supported.',
+      example: '===',
+      required: true
+    },
+
+    nativeQuery: {
+      description: 'A native query for the database.',
+      extendedDescription:
+        'If `valuesToEscape` is provided, this supports template syntax like `?` for SQLite parameter binding.',
+      example: 'SELECT * FROM pets WHERE species=? AND nickname=?',
+      required: true
+    },
+
+    valuesToEscape: {
+      description:
+        'An optional list of strings, numbers, or special literals (true, false, or null) to escape and include in the native query, in order.',
+      extendedDescription:
+        'The first value in the list will be used to replace the first `?`, the second value to replace the second `?`, and so on.',
+      example: '===',
+      defaultsTo: []
+    },
+
+    meta: {
+      friendlyName: 'Meta (custom)',
+      description: 'Additional stuff to pass to the driver.',
+      extendedDescription:
+        'This is reserved for custom driver-specific extensions.',
+      example: '==='
+    }
+  },
+
+  exits: {
+    success: {
+      description: 'The native query was executed successfully.',
+      outputVariableName: 'report',
+      outputDescription:
+        'The `result` property is the result data the database sent back. The `meta` property is reserved for custom driver-specific extensions.',
+      outputExample: '==='
+    },
+
+    queryFailed: {
+      description:
+        'The database returned an error when attempting to execute the native query.',
+      outputVariableName: 'report',
+      outputDescription:
+        'The `error` property is a JavaScript Error instance with more details about what went wrong. The `meta` property is reserved for custom driver-specific extensions.',
+      outputExample: '==='
+    },
+
+    badConnection: {
+      friendlyName: 'Bad connection',
+      description: 'The provided connection is not valid or no longer active.',
+      outputVariableName: 'report',
+      outputDescription:
+        'The `meta` property is reserved for custom driver-specific extensions.',
+      outputExample: '==='
+    }
+  },
+
+  fn: function sendNativeQuery(inputs, exits) {
+    if (!inputs.connection || typeof inputs.connection.prepare !== 'function') {
+      return exits.badConnection()
+    }
+
+    const sql = inputs.nativeQuery
+    const bindings = inputs.valuesToEscape || []
+
+    try {
+      const stmt = inputs.connection.prepare(sql)
+      const isSelect =
+        sql.trim().toUpperCase().startsWith('SELECT') ||
+        sql.trim().toUpperCase().startsWith('PRAGMA')
+      const result = isSelect ? stmt.all(...bindings) : stmt.run(...bindings)
+
+      return exits.success({
+        result: {
+          rows: isSelect ? result : [],
+          changes: result.changes || 0,
+          lastInsertRowid: result.lastInsertRowid
+        },
+        meta: inputs.meta
+      })
+    } catch (err) {
+      return exits.queryFailed({
+        error: err,
+        meta: inputs.meta
+      })
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sails-sqlite",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "SQLite adapter for Sails/Waterline",
   "main": "lib",
   "directories": {