diff --git a/src/database.cc b/src/database.cc
index c8d125cb9..deebab58c 100644
--- a/src/database.cc
+++ b/src/database.cc
@@ -13,16 +13,18 @@ Napi::FunctionReference Database::constructor;
 
 Napi::Object Database::Init(Napi::Env env, Napi::Object exports) {
     Napi::HandleScope scope(env);
+    // declare napi_default_method here as it is only available in Node v14.12.0+
+    napi_property_attributes napi_default_method = static_cast<napi_property_attributes>(napi_writable | napi_configurable); 
 
     Napi::Function t = DefineClass(env, "Database", {
-        InstanceMethod("close", &Database::Close),
-        InstanceMethod("exec", &Database::Exec),
-        InstanceMethod("wait", &Database::Wait),
-        InstanceMethod("loadExtension", &Database::LoadExtension),
-        InstanceMethod("serialize", &Database::Serialize),
-        InstanceMethod("parallelize", &Database::Parallelize),
-        InstanceMethod("configure", &Database::Configure),
-        InstanceMethod("interrupt", &Database::Interrupt),
+        InstanceMethod("close", &Database::Close, napi_default_method),
+        InstanceMethod("exec", &Database::Exec, napi_default_method),
+        InstanceMethod("wait", &Database::Wait, napi_default_method),
+        InstanceMethod("loadExtension", &Database::LoadExtension, napi_default_method),
+        InstanceMethod("serialize", &Database::Serialize, napi_default_method),
+        InstanceMethod("parallelize", &Database::Parallelize, napi_default_method),
+        InstanceMethod("configure", &Database::Configure, napi_default_method),
+        InstanceMethod("interrupt", &Database::Interrupt, napi_default_method),
         InstanceAccessor("open", &Database::OpenGetter, nullptr)
     });
 
diff --git a/test/patching.test.js b/test/patching.test.js
new file mode 100644
index 000000000..bb4debf4f
--- /dev/null
+++ b/test/patching.test.js
@@ -0,0 +1,74 @@
+var sqlite3 = require('..');
+var assert = require('assert');
+
+describe('patching', function() {
+    var db;
+    var originalFunctions = {};
+
+    before(function() {
+        originalFunctions.close = sqlite3.Database.prototype.close;
+        originalFunctions.exec = sqlite3.Database.prototype.exec;
+        originalFunctions.wait = sqlite3.Database.prototype.wait;
+        originalFunctions.loadExtension = sqlite3.Database.prototype.loadExtension;
+        originalFunctions.serialize = sqlite3.Database.prototype.serialize;
+        originalFunctions.parallelize = sqlite3.Database.prototype.parallelize;
+        originalFunctions.configure = sqlite3.Database.prototype.configure;
+        originalFunctions.interrupt = sqlite3.Database.prototype.interrupt;
+    });
+
+    it('allow patching native functions', function() {
+        var myFun = function myFunction() {
+            return "Success";
+        }
+        
+        assert.doesNotThrow(() => {
+            sqlite3.Database.prototype.close = myFun;
+        });
+        assert.doesNotThrow(() => {
+            sqlite3.Database.prototype.exec = myFun;
+        });
+        assert.doesNotThrow(() => {
+            sqlite3.Database.prototype.wait = myFun;
+        });
+        assert.doesNotThrow(() => {
+            sqlite3.Database.prototype.loadExtension = myFun;
+        });
+        assert.doesNotThrow(() => {
+            sqlite3.Database.prototype.serialize = myFun;
+        });
+        assert.doesNotThrow(() => {
+            sqlite3.Database.prototype.parallelize = myFun;
+        });
+        assert.doesNotThrow(() => {
+            sqlite3.Database.prototype.configure = myFun;
+        });
+        assert.doesNotThrow(() => {
+            sqlite3.Database.prototype.interrupt = myFun;
+        });
+
+        db = new sqlite3.Database(':memory:');
+        assert.strictEqual(db.close(), "Success");
+        assert.strictEqual(db.exec(), "Success");
+        assert.strictEqual(db.wait(), "Success");
+        assert.strictEqual(db.loadExtension(), "Success");
+        assert.strictEqual(db.serialize(), "Success");
+        assert.strictEqual(db.parallelize(), "Success");
+        assert.strictEqual(db.configure(), "Success");
+        assert.strictEqual(db.interrupt(), "Success");
+    });
+
+    after(function() {
+        if(db != null) {
+            sqlite3.Database.prototype.close = originalFunctions.close;
+            sqlite3.Database.prototype.exec = originalFunctions.exec;
+            sqlite3.Database.prototype.wait = originalFunctions.wait;
+            sqlite3.Database.prototype.loadExtension = originalFunctions.loadExtension;
+            sqlite3.Database.prototype.serialize = originalFunctions.serialize;
+            sqlite3.Database.prototype.parallelize = originalFunctions.parallelize;
+            sqlite3.Database.prototype.configure = originalFunctions.configure;
+            sqlite3.Database.prototype.interrupt = originalFunctions.interrupt;
+            db.close();
+        }
+    });
+
+});