Skip to content

Commit 7af07bc

Browse files
BurningEnlightenmentBurningEnlightenment
committed
sqlite: extract common database ctor option parsing
1 parent d3bb0bd commit 7af07bc

1 file changed

Lines changed: 175 additions & 163 deletions

File tree

‎src/node_sqlite.cc‎

Lines changed: 175 additions & 163 deletions
Original file line numberDiff line numberDiff line change
@@ -925,6 +925,7 @@ void DatabaseSync::CreateTagStore(const FunctionCallbackInfo<Value>& args) {
925925
args.GetReturnValue().Set(session->object());
926926
}
927927

928+
namespace {
928929
std::optional<std::string> ValidateDatabasePath(Environment* env,
929930
Local<Value> path,
930931
const std::string& field_name) {
@@ -972,206 +973,217 @@ std::optional<std::string> ValidateDatabasePath(Environment* env,
972973
return std::nullopt;
973974
}
974975

975-
void DatabaseSync::New(const FunctionCallbackInfo<Value>& args) {
976-
Environment* env = Environment::GetCurrent(args);
977-
if (!args.IsConstructCall()) {
978-
THROW_ERR_CONSTRUCT_CALL_REQUIRED(env);
979-
return;
976+
bool ParseCommonDatabaseOptions(Environment* env,
977+
Local<Object> options,
978+
DatabaseOpenConfiguration& open_config,
979+
bool& open,
980+
bool& allow_load_extension) {
981+
Local<String> open_string = FIXED_ONE_BYTE_STRING(env->isolate(), "open");
982+
Local<Value> open_v;
983+
if (!options->Get(env->context(), open_string).ToLocal(&open_v)) {
984+
return false;
980985
}
981-
982-
std::optional<std::string> location =
983-
ValidateDatabasePath(env, args[0], "path");
984-
if (!location.has_value()) {
985-
return;
986+
if (!open_v->IsUndefined()) {
987+
if (!open_v->IsBoolean()) {
988+
THROW_ERR_INVALID_ARG_TYPE(
989+
env->isolate(), "The \"options.open\" argument must be a boolean.");
990+
return false;
991+
}
992+
open = open_v.As<Boolean>()->Value();
986993
}
987994

988-
DatabaseOpenConfiguration open_config(std::move(location.value()));
989-
bool open = true;
990-
bool allow_load_extension = false;
991-
if (args.Length() > 1) {
992-
if (!args[1]->IsObject()) {
993-
THROW_ERR_INVALID_ARG_TYPE(env->isolate(),
994-
"The \"options\" argument must be an object.");
995-
return;
995+
Local<String> read_only_string =
996+
FIXED_ONE_BYTE_STRING(env->isolate(), "readOnly");
997+
Local<Value> read_only_v;
998+
if (!options->Get(env->context(), read_only_string).ToLocal(&read_only_v)) {
999+
return false;
1000+
}
1001+
if (!read_only_v->IsUndefined()) {
1002+
if (!read_only_v->IsBoolean()) {
1003+
THROW_ERR_INVALID_ARG_TYPE(
1004+
env->isolate(),
1005+
"The \"options.readOnly\" argument must be a boolean.");
1006+
return false;
9961007
}
1008+
open_config.set_read_only(read_only_v.As<Boolean>()->Value());
1009+
}
9971010

998-
Local<Object> options = args[1].As<Object>();
999-
Local<String> open_string = FIXED_ONE_BYTE_STRING(env->isolate(), "open");
1000-
Local<Value> open_v;
1001-
if (!options->Get(env->context(), open_string).ToLocal(&open_v)) {
1002-
return;
1003-
}
1004-
if (!open_v->IsUndefined()) {
1005-
if (!open_v->IsBoolean()) {
1006-
THROW_ERR_INVALID_ARG_TYPE(
1007-
env->isolate(), "The \"options.open\" argument must be a boolean.");
1008-
return;
1009-
}
1010-
open = open_v.As<Boolean>()->Value();
1011+
Local<String> enable_foreign_keys_string =
1012+
FIXED_ONE_BYTE_STRING(env->isolate(), "enableForeignKeyConstraints");
1013+
Local<Value> enable_foreign_keys_v;
1014+
if (!options->Get(env->context(), enable_foreign_keys_string)
1015+
.ToLocal(&enable_foreign_keys_v)) {
1016+
return false;
1017+
}
1018+
if (!enable_foreign_keys_v->IsUndefined()) {
1019+
if (!enable_foreign_keys_v->IsBoolean()) {
1020+
THROW_ERR_INVALID_ARG_TYPE(
1021+
env->isolate(),
1022+
"The \"options.enableForeignKeyConstraints\" argument must be a "
1023+
"boolean.");
1024+
return false;
10111025
}
1026+
open_config.set_enable_foreign_keys(
1027+
enable_foreign_keys_v.As<Boolean>()->Value());
1028+
}
10121029

1013-
Local<String> read_only_string =
1014-
FIXED_ONE_BYTE_STRING(env->isolate(), "readOnly");
1015-
Local<Value> read_only_v;
1016-
if (!options->Get(env->context(), read_only_string).ToLocal(&read_only_v)) {
1017-
return;
1018-
}
1019-
if (!read_only_v->IsUndefined()) {
1020-
if (!read_only_v->IsBoolean()) {
1021-
THROW_ERR_INVALID_ARG_TYPE(
1022-
env->isolate(),
1023-
"The \"options.readOnly\" argument must be a boolean.");
1024-
return;
1025-
}
1026-
open_config.set_read_only(read_only_v.As<Boolean>()->Value());
1030+
Local<String> enable_dqs_string =
1031+
FIXED_ONE_BYTE_STRING(env->isolate(), "enableDoubleQuotedStringLiterals");
1032+
Local<Value> enable_dqs_v;
1033+
if (!options->Get(env->context(), enable_dqs_string).ToLocal(&enable_dqs_v)) {
1034+
return false;
1035+
}
1036+
if (!enable_dqs_v->IsUndefined()) {
1037+
if (!enable_dqs_v->IsBoolean()) {
1038+
THROW_ERR_INVALID_ARG_TYPE(
1039+
env->isolate(),
1040+
"The \"options.enableDoubleQuotedStringLiterals\" argument must be "
1041+
"a boolean.");
1042+
return false;
10271043
}
1044+
open_config.set_enable_dqs(enable_dqs_v.As<Boolean>()->Value());
1045+
}
10281046

1029-
Local<String> enable_foreign_keys_string =
1030-
FIXED_ONE_BYTE_STRING(env->isolate(), "enableForeignKeyConstraints");
1031-
Local<Value> enable_foreign_keys_v;
1032-
if (!options->Get(env->context(), enable_foreign_keys_string)
1033-
.ToLocal(&enable_foreign_keys_v)) {
1034-
return;
1035-
}
1036-
if (!enable_foreign_keys_v->IsUndefined()) {
1037-
if (!enable_foreign_keys_v->IsBoolean()) {
1038-
THROW_ERR_INVALID_ARG_TYPE(
1039-
env->isolate(),
1040-
"The \"options.enableForeignKeyConstraints\" argument must be a "
1041-
"boolean.");
1042-
return;
1043-
}
1044-
open_config.set_enable_foreign_keys(
1045-
enable_foreign_keys_v.As<Boolean>()->Value());
1047+
Local<String> allow_extension_string =
1048+
FIXED_ONE_BYTE_STRING(env->isolate(), "allowExtension");
1049+
Local<Value> allow_extension_v;
1050+
if (!options->Get(env->context(), allow_extension_string)
1051+
.ToLocal(&allow_extension_v)) {
1052+
return false;
1053+
}
1054+
1055+
if (!allow_extension_v->IsUndefined()) {
1056+
if (!allow_extension_v->IsBoolean()) {
1057+
THROW_ERR_INVALID_ARG_TYPE(
1058+
env->isolate(),
1059+
"The \"options.allowExtension\" argument must be a boolean.");
1060+
return false;
10461061
}
1062+
allow_load_extension = allow_extension_v.As<Boolean>()->Value();
1063+
}
10471064

1048-
Local<String> enable_dqs_string = FIXED_ONE_BYTE_STRING(
1049-
env->isolate(), "enableDoubleQuotedStringLiterals");
1050-
Local<Value> enable_dqs_v;
1051-
if (!options->Get(env->context(), enable_dqs_string)
1052-
.ToLocal(&enable_dqs_v)) {
1053-
return;
1065+
Local<Value> timeout_v;
1066+
if (!options->Get(env->context(), env->timeout_string())
1067+
.ToLocal(&timeout_v)) {
1068+
return false;
1069+
}
1070+
1071+
if (!timeout_v->IsUndefined()) {
1072+
if (!timeout_v->IsInt32()) {
1073+
THROW_ERR_INVALID_ARG_TYPE(
1074+
env->isolate(),
1075+
"The \"options.timeout\" argument must be an integer.");
1076+
return false;
10541077
}
1055-
if (!enable_dqs_v->IsUndefined()) {
1056-
if (!enable_dqs_v->IsBoolean()) {
1078+
1079+
open_config.set_timeout(timeout_v.As<Int32>()->Value());
1080+
}
1081+
1082+
Local<Value> read_bigints_v;
1083+
if (options->Get(env->context(), env->read_bigints_string())
1084+
.ToLocal(&read_bigints_v)) {
1085+
if (!read_bigints_v->IsUndefined()) {
1086+
if (!read_bigints_v->IsBoolean()) {
10571087
THROW_ERR_INVALID_ARG_TYPE(
10581088
env->isolate(),
1059-
"The \"options.enableDoubleQuotedStringLiterals\" argument must be "
1060-
"a boolean.");
1061-
return;
1089+
R"(The "options.readBigInts" argument must be a boolean.)");
1090+
return false;
10621091
}
1063-
open_config.set_enable_dqs(enable_dqs_v.As<Boolean>()->Value());
1064-
}
1065-
1066-
Local<String> allow_extension_string =
1067-
FIXED_ONE_BYTE_STRING(env->isolate(), "allowExtension");
1068-
Local<Value> allow_extension_v;
1069-
if (!options->Get(env->context(), allow_extension_string)
1070-
.ToLocal(&allow_extension_v)) {
1071-
return;
1092+
open_config.set_use_big_ints(read_bigints_v.As<Boolean>()->Value());
10721093
}
1094+
}
10731095

1074-
if (!allow_extension_v->IsUndefined()) {
1075-
if (!allow_extension_v->IsBoolean()) {
1096+
Local<Value> return_arrays_v;
1097+
if (options->Get(env->context(), env->return_arrays_string())
1098+
.ToLocal(&return_arrays_v)) {
1099+
if (!return_arrays_v->IsUndefined()) {
1100+
if (!return_arrays_v->IsBoolean()) {
10761101
THROW_ERR_INVALID_ARG_TYPE(
10771102
env->isolate(),
1078-
"The \"options.allowExtension\" argument must be a boolean.");
1079-
return;
1103+
R"(The "options.returnArrays" argument must be a boolean.)");
1104+
return false;
10801105
}
1081-
allow_load_extension = allow_extension_v.As<Boolean>()->Value();
1106+
open_config.set_return_arrays(return_arrays_v.As<Boolean>()->Value());
10821107
}
1108+
}
10831109

1084-
Local<Value> timeout_v;
1085-
if (!options->Get(env->context(), env->timeout_string())
1086-
.ToLocal(&timeout_v)) {
1087-
return;
1110+
Local<Value> allow_bare_named_params_v;
1111+
if (options->Get(env->context(), env->allow_bare_named_params_string())
1112+
.ToLocal(&allow_bare_named_params_v)) {
1113+
if (!allow_bare_named_params_v->IsUndefined()) {
1114+
if (!allow_bare_named_params_v->IsBoolean()) {
1115+
THROW_ERR_INVALID_ARG_TYPE(env->isolate(),
1116+
R"(The "options.allowBareNamedParameters" )"
1117+
"argument must be a boolean.");
1118+
return false;
1119+
}
1120+
open_config.set_allow_bare_named_params(
1121+
allow_bare_named_params_v.As<Boolean>()->Value());
10881122
}
1123+
}
10891124

1090-
if (!timeout_v->IsUndefined()) {
1091-
if (!timeout_v->IsInt32()) {
1125+
Local<Value> allow_unknown_named_params_v;
1126+
if (options->Get(env->context(), env->allow_unknown_named_params_string())
1127+
.ToLocal(&allow_unknown_named_params_v)) {
1128+
if (!allow_unknown_named_params_v->IsUndefined()) {
1129+
if (!allow_unknown_named_params_v->IsBoolean()) {
10921130
THROW_ERR_INVALID_ARG_TYPE(
10931131
env->isolate(),
1094-
"The \"options.timeout\" argument must be an integer.");
1095-
return;
1132+
R"(The "options.allowUnknownNamedParameters" )"
1133+
"argument must be a boolean.");
1134+
return false;
10961135
}
1097-
1098-
open_config.set_timeout(timeout_v.As<Int32>()->Value());
1136+
open_config.set_allow_unknown_named_params(
1137+
allow_unknown_named_params_v.As<Boolean>()->Value());
10991138
}
1139+
}
11001140

1101-
Local<Value> read_bigints_v;
1102-
if (options->Get(env->context(), env->read_bigints_string())
1103-
.ToLocal(&read_bigints_v)) {
1104-
if (!read_bigints_v->IsUndefined()) {
1105-
if (!read_bigints_v->IsBoolean()) {
1106-
THROW_ERR_INVALID_ARG_TYPE(
1107-
env->isolate(),
1108-
R"(The "options.readBigInts" argument must be a boolean.)");
1109-
return;
1110-
}
1111-
open_config.set_use_big_ints(read_bigints_v.As<Boolean>()->Value());
1112-
}
1141+
Local<Value> defensive_v;
1142+
if (!options->Get(env->context(), env->defensive_string())
1143+
.ToLocal(&defensive_v)) {
1144+
return false;
1145+
}
1146+
if (!defensive_v->IsUndefined()) {
1147+
if (!defensive_v->IsBoolean()) {
1148+
THROW_ERR_INVALID_ARG_TYPE(
1149+
env->isolate(),
1150+
"The \"options.defensive\" argument must be a boolean.");
1151+
return false;
11131152
}
1153+
open_config.set_enable_defensive(defensive_v.As<Boolean>()->Value());
1154+
}
1155+
return true;
1156+
}
1157+
} // namespace
11141158

1115-
Local<Value> return_arrays_v;
1116-
if (options->Get(env->context(), env->return_arrays_string())
1117-
.ToLocal(&return_arrays_v)) {
1118-
if (!return_arrays_v->IsUndefined()) {
1119-
if (!return_arrays_v->IsBoolean()) {
1120-
THROW_ERR_INVALID_ARG_TYPE(
1121-
env->isolate(),
1122-
R"(The "options.returnArrays" argument must be a boolean.)");
1123-
return;
1124-
}
1125-
open_config.set_return_arrays(return_arrays_v.As<Boolean>()->Value());
1126-
}
1127-
}
1159+
void DatabaseSync::New(const FunctionCallbackInfo<Value>& args) {
1160+
Environment* env = Environment::GetCurrent(args);
1161+
if (!args.IsConstructCall()) {
1162+
THROW_ERR_CONSTRUCT_CALL_REQUIRED(env);
1163+
return;
1164+
}
11281165

1129-
Local<Value> allow_bare_named_params_v;
1130-
if (options->Get(env->context(), env->allow_bare_named_params_string())
1131-
.ToLocal(&allow_bare_named_params_v)) {
1132-
if (!allow_bare_named_params_v->IsUndefined()) {
1133-
if (!allow_bare_named_params_v->IsBoolean()) {
1134-
THROW_ERR_INVALID_ARG_TYPE(
1135-
env->isolate(),
1136-
R"(The "options.allowBareNamedParameters" )"
1137-
"argument must be a boolean.");
1138-
return;
1139-
}
1140-
open_config.set_allow_bare_named_params(
1141-
allow_bare_named_params_v.As<Boolean>()->Value());
1142-
}
1143-
}
1166+
std::optional<std::string> location =
1167+
ValidateDatabasePath(env, args[0], "path");
1168+
if (!location.has_value()) {
1169+
return;
1170+
}
11441171

1145-
Local<Value> allow_unknown_named_params_v;
1146-
if (options->Get(env->context(), env->allow_unknown_named_params_string())
1147-
.ToLocal(&allow_unknown_named_params_v)) {
1148-
if (!allow_unknown_named_params_v->IsUndefined()) {
1149-
if (!allow_unknown_named_params_v->IsBoolean()) {
1150-
THROW_ERR_INVALID_ARG_TYPE(
1151-
env->isolate(),
1152-
R"(The "options.allowUnknownNamedParameters" )"
1153-
"argument must be a boolean.");
1154-
return;
1155-
}
1156-
open_config.set_allow_unknown_named_params(
1157-
allow_unknown_named_params_v.As<Boolean>()->Value());
1158-
}
1172+
DatabaseOpenConfiguration open_config(std::move(location.value()));
1173+
bool open = true;
1174+
bool allow_load_extension = false;
1175+
if (args.Length() > 1) {
1176+
if (!args[1]->IsObject()) {
1177+
THROW_ERR_INVALID_ARG_TYPE(env->isolate(),
1178+
"The \"options\" argument must be an object.");
1179+
return;
11591180
}
11601181

1161-
Local<Value> defensive_v;
1162-
if (!options->Get(env->context(), env->defensive_string())
1163-
.ToLocal(&defensive_v)) {
1182+
Local<Object> options = args[1].As<Object>();
1183+
if (!ParseCommonDatabaseOptions(
1184+
env, options, open_config, open, allow_load_extension)) {
11641185
return;
11651186
}
1166-
if (!defensive_v->IsUndefined()) {
1167-
if (!defensive_v->IsBoolean()) {
1168-
THROW_ERR_INVALID_ARG_TYPE(
1169-
env->isolate(),
1170-
"The \"options.defensive\" argument must be a boolean.");
1171-
return;
1172-
}
1173-
open_config.set_enable_defensive(defensive_v.As<Boolean>()->Value());
1174-
}
11751187
}
11761188

11771189
new DatabaseSync(

0 commit comments

Comments
 (0)