@superhero/db 1.0.0 → 1.0.1-rc.0

package/adapter/mysql/index.js

@@ -38,13 +38,10 @@ class AdapterMySql
     return new Promise(resolve)
   }
 
-  async createTransaction()
+  async createTransaction(connection = await this.getConnection())
   {
-    const connection  = await this.getConnection()
     await connection.query('START TRANSACTION')
-    const transaction = new AdapterMySqlTransaction(connection)
-
-    return transaction
+    return new AdapterMySqlTransaction(connection)
   }
 
   close()

package/adapter/mysql/transaction.js

@@ -12,14 +12,7 @@ class AdapterMySqlTransaction
     throw new NestedTransactionsNotAllowed('Nested transactions are not allowed')
   }
 
-  query(...args)
-  {
-    return this._query(...args)
-  }
-
-  // We are forced to have a different query function to be able to use it from inside
-  // the class without the Proxy making interferences
-  async _query(query, ...ctx)
+  query(query, ...ctx)
   {
     return new Promise((accept, reject) =>
       this.connection.query(query, ...ctx, (error, response) =>
@@ -30,13 +23,13 @@ class AdapterMySqlTransaction
 
   async commit()
   {
-    await this._query('COMMIT')
+    await this.query('COMMIT')
     this.connection.release()
   }
 
   async rollback()
   {
-    await this._query('ROLLBACK')
+    await this.query('ROLLBACK')
     this.connection.release()
   }
 }

package/adapter/mysql2/index.js

@@ -38,13 +38,51 @@ class AdapterMySql2
     return new Promise(resolve)
   }
 
-  async createTransaction()
+  async lock(
+    reference, 
+    operation,
+    timeout     = 10, 
+    connection  = await this.getConnection())
   {
-    const connection  = await this.getConnection()
-    await connection.query('START TRANSACTION')
-    const transaction = new AdapterMySql2Transaction(connection)
+    try
+    {
+      const
+        result = await connection.query('SELECT GET_LOCK(?, ?) as status', [reference, timeout]),
+        status = result[0].status
+
+      if(1 === status)
+      {
+        await operation(connection)
+      }
+      else if(0 === status)
+      {
+        const error     = new Error(`advisory lock '${reference}' is busy by a different process`)
+        error.code      = 'DB_LOCK_TIMEOUT'
+        error.reference = reference
+        error.timeout   = timeout
+        throw error
+      }
+      else
+      {
+        const error     = new Error(`something is wrong with the query for the advisory lock '${reference}'`)
+        error.code      = 'E_EVENTFLOW_DB_ADVISORY_LOCK_NULL_RESULT'
+        error.reference = reference
+        error.timeout   = timeout
+        throw error
+      }
+    }
+    finally
+    {
+      await connection.query('DO RELEASE_LOCK(?)', [reference])
+        .then(() => connection.release())
+        .catch(() => connection.end())
+    }
+  }
 
-    return transaction
+  async createTransaction(connection = await this.getConnection())
+  {
+    await connection.query('START TRANSACTION')
+    return new AdapterMySql2Transaction(connection)
   }
 
   close()

package/adapter/mysql2/transaction.js

@@ -12,14 +12,7 @@ class AdapterMySql2Transaction
     throw new NestedTransactionsNotAllowed('Nested transactions are not allowed')
   }
 
-  query(...args)
-  {
-    return this._query(...args)
-  }
-
-  // We are forced to have a different query function to be able to use it from inside
-  // the class without the Proxy making interferences
-  async _query(query, ...ctx)
+  query(query, ...ctx)
   {
     return new Promise((accept, reject) =>
       this.connection.query(query, ...ctx, (error, response) =>
@@ -30,13 +23,13 @@ class AdapterMySql2Transaction
 
   async commit()
   {
-    await this._query('COMMIT')
+    await this.query('COMMIT')
     this.connection.release()
   }
 
   async rollback()
   {
-    await this._query('ROLLBACK')
+    await this.query('ROLLBACK')
     this.connection.release()
   }
 }

package/index.js

@@ -1,6 +1,7 @@
 const
   util        = require('util'),
   fs          = require('fs'),
+  os          = require('os'),
   promisify   = util.promisify,
   readFile    = promisify(fs.readFile)
 
@@ -9,7 +10,7 @@ class Db
   constructor(adaptor, queryPath, fileSuffix = '')
   {
     this.adaptor    = adaptor
-    this.queryPath  = require('path').normalize(queryPath) + '/'
+    this.queryPath  = require('path').normalize(queryPath) + os.EOL
     this.fileSuffix = fileSuffix
     this.queries    = {}
   }
@@ -21,14 +22,7 @@ class Db
 
   async query(file, ...ctx)
   {
-    let query = await this.getQuery(file)
-
-    for(let noEscapeReplace = query.indexOf('?%s');
-            noEscapeReplace > -1;
-            noEscapeReplace = query.indexOf('?%s'))
-    {
-      query = query.replace('?%s', ctx.shift())
-    }
+    let query = await this.getQuery(file, ctx)
   
     try
     {
@@ -36,52 +30,73 @@ class Db
     }
     catch(reason)
     {
-      const error = new Error(`DB query '${file}' failed`)
-      error.code  = 'DB_QUERY_ERROR'
-      error.query = this.adaptor.getFormattedQuery?.(query, ...ctx) ?? query
-      error.cause = reason
-      throw error
+      this._throwOnQueryError(reason, file, query, ctx)
     }
   }
 
-  async formatQuery(file, formatCtx, sqlCtx)
+  async lock(...args)
   {
-    const
-      query           = await this.getQuery(file),
-      formattedQuery  = util.format(query, ...formatCtx),
-      response        = await this.adaptor.query(formattedQuery, ...sqlCtx)
-
-    return response
+    if('lock' in this.adaptor)
+    {
+      await this.adaptor.lock(...args)
+    }
+    else
+    {
+      throw new Error('The database adapter provided does not support locking')
+    }
   }
 
-  async createTransaction()
+  async createTransaction(connection)
   {
-    const transaction = await this.adaptor.createTransaction()
+    const transaction = await this.adaptor.createTransaction(connection)
 
     return new Proxy(transaction,
     {
-      get: (target, property) =>
+      get: (target, member) =>
       {
-        return property !== 'query'
-        ? target[property]
+        return 'query' !== member
+        ? Reflect.get(target, member, target)
         : async (file, ...ctx) =>
         {
-          const
-            query     = await this.getQuery(file),
-            response  = await transaction.query(query, ...ctx)
+          const query = await this.getQuery(file, ctx)
 
-          return response
+          try
+          {
+            const method = Reflect.get(target, member, target)
+            return await Reflect.apply(method, target, [query, ...ctx])
+          }
+          catch(reason)
+          {
+            this._throwOnQueryError(reason, file, query, ctx)
+          }
         }
       }
     })
   }
 
-  async getQuery(file)
+  async getQuery(file, ctx)
   {
-    const query = file in this.queries
+    const buffer = file in this.queries
     ? this.queries[file]
     : this.queries[file] = await readFile(this.queryPath + file + this.fileSuffix)
-    return query.toString()
+
+    let query = buffer.toString()
+
+    while(ctx.length && query.indexOf('?%s') > -1)
+    {
+      query = query.replace('?%s', ctx.shift())
+    }
+
+    return query
+  }
+
+  _throwOnQueryError(reason, file, query, ctx)
+  {
+    const error = new Error(`DB query '${file}' failed`)
+    error.code  = 'DB_QUERY_ERROR'
+    error.query = this.adaptor.getFormattedQuery?.(query, ...ctx) ?? query
+    error.cause = reason
+    throw error
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@superhero/db",
-  "version": "1.0.0",
+  "version": "1.0.1-rc.0",
   "description": "Db interaction, designed to separate queries from the source code",
   "repository": {
     "type": "git",