Make connection.close() the primary method in the code, not just in the documentation

Author: cjbj

lib/connection.js

@@ -26,7 +26,7 @@ var executePromisified;
 var commitPromisified;
 var createLobPromisified;
 var rollbackPromisified;
-var releasePromisified;
+var closePromisified;
 var breakPromisified;
 var changePasswordPromisified;
 
@@ -218,26 +218,26 @@ function rollback(rollbackCb) {
 
 rollbackPromisified = nodbUtil.promisify(rollback);
 
-// This release function is used to override the release method of the Connection
+// This close function is used to override the close method of the Connection
 // class, which is defined in the C layer.
-function release(releaseCb) {
+function close(closeCb) {
   var self = this;
 
   nodbUtil.assert(arguments.length === 1, 'NJS-009');
-  nodbUtil.assert(typeof releaseCb === 'function', 'NJS-006', 1);
+  nodbUtil.assert(typeof closeCb === 'function', 'NJS-006', 1);
 
-  self._release(function(err) {
+  self._close(function(err) {
     if (!err) {
       self.emit('_after_close');
     }
 
-    releaseCb(err);
+    closeCb(err);
   });
 }
 
-releasePromisified = nodbUtil.promisify(release);
+closePromisified = nodbUtil.promisify(close);
 
-// This release function is just a place holder to allow for easier extension later.
+// This break function is just a place holder to allow for easier extension later.
 // It's attached to the module as break is a reserved word.
 module.break = function(breakCb) {
   var self = this;
@@ -319,16 +319,16 @@ function extend(conn, oracledb, pool) {
         enumerable: true,
         writable: true
       },
-      _release: {
-        value: conn.release
+      _close: {
+        value: conn.close
       },
-      release: {
-        value: releasePromisified,
+      close: {
+        value: closePromisified,
         enumerable: true,
         writable: true
       },
-      close: { // alias for release
-        value: releasePromisified,
+      release: { // alias for close
+        value: closePromisified,
         enumerable: true,
         writable: true
       },

src/njsConnection.cpp

@@ -80,7 +80,7 @@ void njsConnection::Init(Handle<Object> target)
     tpl->SetClassName(Nan::New<v8::String>("Connection").ToLocalChecked());
 
     Nan::SetPrototypeMethod(tpl, "execute", Execute);
-    Nan::SetPrototypeMethod(tpl, "release", Release);
+    Nan::SetPrototypeMethod(tpl, "close", Close);
     Nan::SetPrototypeMethod(tpl, "commit", Commit);
     Nan::SetPrototypeMethod(tpl, "rollback", Rollback);
     Nan::SetPrototypeMethod(tpl, "break", Break);
@@ -1481,7 +1481,7 @@ void njsConnection::Async_AfterExecute(njsBaton *baton, Local<Value> argv[])
 
 
 //-----------------------------------------------------------------------------
-// njsConnection::Release()
+// njsConnection::Close()
 //   Releases the connection from use by JS. This releases the connection back
 // to the pool or closes the standalone connection so further use is not
 // possible. The reference to the DPI handle is transferred to the baton so
@@ -1491,7 +1491,7 @@ void njsConnection::Async_AfterExecute(njsBaton *baton, Local<Value> argv[])
 // PARAMETERS
 //   - JS callback which will receive (error)
 //-----------------------------------------------------------------------------
-NAN_METHOD(njsConnection::Release)
+NAN_METHOD(njsConnection::Close)
 {
     njsConnection *connection;
     njsBaton *baton;
@@ -1504,17 +1504,17 @@ NAN_METHOD(njsConnection::Release)
         return;
     baton->dpiConnHandle = connection->dpiConnHandle;
     connection->dpiConnHandle = NULL;
-    baton->QueueWork("Release", Async_Release, NULL, 1);
+    baton->QueueWork("Close", Async_Close, NULL, 1);
 }
 
 
 //-----------------------------------------------------------------------------
-// njsConnection::Async_Release()
-//   Worker function for njsConnection::Release() method. If the attempt to
+// njsConnection::Async_Close()
+//   Worker function for njsConnection::Close() method. If the attempt to
 // close fails, the reference to the DPI handle is transferred back from the
 // baton to the connection.
 //-----------------------------------------------------------------------------
-void njsConnection::Async_Release(njsBaton *baton)
+void njsConnection::Async_Close(njsBaton *baton)
 {
     if (dpiConn_close(baton->dpiConnHandle, DPI_MODE_CONN_CLOSE_DEFAULT, NULL,
             0) < 0) {
@@ -1527,10 +1527,10 @@ void njsConnection::Async_Release(njsBaton *baton)
 
 
 //-----------------------------------------------------------------------------
-// njsConnection::Async_AfterRelease()
-//   Finishes release by cleaning up references.
+// njsConnection::Async_AfterClose()
+//   Finishes close by cleaning up references.
 //-----------------------------------------------------------------------------
-void njsConnection::Async_AfterRelease(njsBaton *baton, Local<Value> argv[])
+void njsConnection::Async_AfterClose(njsBaton *baton, Local<Value> argv[])
 {
     njsConnection *connection = (njsConnection*) baton->callingObj;
     connection->jsOracledb.Reset();

src/njsConnection.h

@@ -98,10 +98,10 @@ class njsConnection: public njsCommon {
     static void Async_Execute(njsBaton *baton);
     static void Async_AfterExecute(njsBaton *baton, Local<Value> argv[]);
 
-    // Release Method on Connection class
-    static NAN_METHOD(Release);
-    static void Async_Release(njsBaton *baton);
-    static void Async_AfterRelease(njsBaton *baton, Local<Value> argv[]);
+    // Close Method on Connection class
+    static NAN_METHOD(Close);
+    static void Async_Close(njsBaton *baton);
+    static void Async_AfterClose(njsBaton *baton, Local<Value> argv[]);
 
     // Commit Method on Connection class
     static NAN_METHOD(Commit);