src: cleanup sqlite async api

Author: geeksilva97

src/node_sqlite.cc

@@ -1129,6 +1129,21 @@ inline void DatabaseNew(const FunctionCallbackInfo<Value>& args,
             allow_unknown_named_params_v.As<Boolean>()->Value());
       }
     }
+
+    Local<Value> defensive_v;
+    if (!options->Get(env->context(), env->defensive_string())
+             .ToLocal(&defensive_v)) {
+      return;
+    }
+    if (!defensive_v->IsUndefined()) {
+      if (!defensive_v->IsBoolean()) {
+        THROW_ERR_INVALID_ARG_TYPE(
+            env->isolate(),
+            "The \"options.defensive\" argument must be a boolean.");
+        return;
+      }
+      open_config.set_enable_defensive(defensive_v.As<Boolean>()->Value());
+    }
   }
 
   open_config.set_async(async);
@@ -2576,8 +2591,10 @@ MaybeLocal<Promise::Resolver> StatementAsyncExecutionHelper::All(
       }
     }
 
-    resolver->Resolve(env->context(),
-                      Array::New(isolate, js_rows.data(), js_rows.size()));
+    resolver
+        ->Resolve(env->context(),
+                  Array::New(isolate, js_rows.data(), js_rows.size()))
+        .FromJust();
   };
 
   Local<Promise::Resolver> resolver =
@@ -2647,7 +2664,6 @@ MaybeLocal<Promise::Resolver> StatementAsyncExecutionHelper::Get(
 
 MaybeLocal<Promise::Resolver> StatementAsyncExecutionHelper::Run(
     Environment* env, Statement* stmt) {
-  Isolate* isolate = env->isolate();
   Database* db = stmt->db_.get();
   sqlite3* conn = db->Connection();
   auto task =
@@ -3379,61 +3395,16 @@ void SQLTagStore::MemoryInfo(MemoryTracker* tracker) const {
   tracker->TrackFieldWithSize("sql_tags_cache", cache_content_size);
 }
 
-// TODO(geeksilva97): move this to a common location if other classes need it
-inline Local<FunctionTemplate> GetStatementConstructorTemplate(
-    Isolate* isolate) {
-  Local<FunctionTemplate> tmpl =
-      NewFunctionTemplate(isolate, IllegalConstructor);
-  tmpl->InstanceTemplate()->SetInternalFieldCount(
-      Statement::kInternalFieldCount);
-  SetProtoMethod(isolate, tmpl, "iterate", Statement::Iterate);
-  SetProtoMethod(isolate, tmpl, "all", Statement::All);
-  SetProtoMethod(isolate, tmpl, "get", Statement::Get);
-  SetProtoMethod(isolate, tmpl, "run", Statement::Run);
-  SetProtoMethodNoSideEffect(isolate, tmpl, "columns", Statement::Columns);
-  SetSideEffectFreeGetter(isolate,
-                          tmpl,
-                          FIXED_ONE_BYTE_STRING(isolate, "sourceSQL"),
-                          Statement::SourceSQLGetter);
-  SetSideEffectFreeGetter(isolate,
-                          tmpl,
-                          FIXED_ONE_BYTE_STRING(isolate, "expandedSQL"),
-                          Statement::ExpandedSQLGetter);
-  SetProtoMethod(isolate,
-                 tmpl,
-                 "setAllowBareNamedParameters",
-                 Statement::SetAllowBareNamedParameters);
-  SetProtoMethod(isolate,
-                 tmpl,
-                 "setAllowUnknownNamedParameters",
-                 Statement::SetAllowUnknownNamedParameters);
-  SetProtoMethod(isolate, tmpl, "setReadBigInts", Statement::SetReadBigInts);
-  SetProtoMethod(isolate, tmpl, "setReturnArrays", Statement::SetReturnArrays);
-
-  return tmpl;
-}
-
-Local<FunctionTemplate> Statement::GetConstructorTemplate(
-    Environment* env, std::string_view name = "Statement") {
-  Isolate* isolate = env->isolate();
-  Local<FunctionTemplate> tmpl = GetStatementConstructorTemplate(isolate);
-  Local<String> class_name;
-  if (!String::NewFromUtf8(isolate, name.data()).ToLocal(&class_name)) {
-    return Local<FunctionTemplate>();
-  }
-
-  tmpl->SetClassName(class_name);
-  return tmpl;
-}
-
 BaseObjectPtr<Statement> Statement::Create(Environment* env,
                                            BaseObjectPtr<Database> db,
                                            sqlite3_stmt* stmt) {
+  Local<FunctionTemplate> tmpl =
+      env->sqlite_statement_async_constructor_template();
+  if (!db->is_async()) {
+    tmpl = env->sqlite_statement_sync_constructor_template();
+  }
   Local<Object> obj;
-  if (!GetConstructorTemplate(env)
-           ->InstanceTemplate()
-           ->NewInstance(env->context())
-           .ToLocal(&obj)) {
+  if (!tmpl->InstanceTemplate()->NewInstance(env->context()).ToLocal(&obj)) {
     return nullptr;
   }
 

src/node_sqlite.h

@@ -247,8 +247,6 @@ class Statement : public BaseObject {
             BaseObjectPtr<Database> db,
             sqlite3_stmt* stmt);
   void MemoryInfo(MemoryTracker* tracker) const override;
-  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
-      Environment* env, std::string_view class_name);
   static BaseObjectPtr<Statement> Create(Environment* env,
                                          BaseObjectPtr<Database> db,
                                          sqlite3_stmt* stmt);