#include "node_sqlite.h"

#include <path.h>

#include "base_object-inl.h"

#include "debug_utils-inl.h"

#include "env-inl.h"

#include "memory_tracker-inl.h"

#include "node.h"

#include "node_errors.h"

#include "node_mem-inl.h"

#include "node_url.h"

#include "sqlite3.h"

#include "threadpoolwork-inl.h"

#include "util-inl.h"

#include <cinttypes>

namespace node {

namespace sqlite {

using v8::Array;

using v8::ArrayBuffer;

using v8::BackingStoreInitializationMode;

using v8::BigInt;

using v8::Boolean;

using v8::ConstructorBehavior;

using v8::Context;

using v8::DictionaryTemplate;

using v8::DontDelete;

using v8::EscapableHandleScope;

using v8::Exception;

using v8::Function;

using v8::FunctionCallback;

using v8::FunctionCallbackInfo;

using v8::FunctionTemplate;

using v8::Global;

using v8::HandleScope;

using v8::Int32;

using v8::Integer;

using v8::Isolate;

using v8::JustVoid;

using v8::Local;

using v8::LocalVector;

using v8::Maybe;

using v8::MaybeLocal;

using v8::Name;

using v8::NewStringType;

using v8::Nothing;

using v8::Null;

using v8::Number;

using v8::Object;

using v8::Promise;

using v8::SideEffectType;

using v8::String;

using v8::TryCatch;

using v8::Uint8Array;

using v8::Value;

#define CHECK_ERROR_OR_THROW(isolate, db, expr, expected, ret) \

do { \

int r_ = (expr); \

if (r_ != (expected)) { \

THROW_ERR_SQLITE_ERROR((isolate), (db)); \

return (ret); \

} \

} while (0)

#define THROW_AND_RETURN_ON_BAD_STATE(env, condition, msg) \

do { \

if ((condition)) { \

THROW_ERR_INVALID_STATE((env), (msg)); \

return; \

} \

} while (0)

#define SQLITE_VALUE_TO_JS(from, isolate, use_big_int_args, result, ...) \

do { \

switch (sqlite3_##from##_type(__VA_ARGS__)) { \

case SQLITE_INTEGER: { \

sqlite3_int64 val = sqlite3_##from##_int64(__VA_ARGS__); \

if ((use_big_int_args)) { \

(result) = BigInt::New((isolate), val); \

} else if (std::abs(val) <= kMaxSafeJsInteger) { \

(result) = Number::New((isolate), val); \

} else { \

THROW_ERR_OUT_OF_RANGE((isolate), \

"Value is too large to be represented as a " \

"JavaScript number: %" PRId64, \

val); \

} \

break; \

} \

case SQLITE_FLOAT: { \

(result) = \

Number::New((isolate), sqlite3_##from##_double(__VA_ARGS__)); \

break; \

} \

case SQLITE_TEXT: { \

const char* v = \

reinterpret_cast<const char*>(sqlite3_##from##_text(__VA_ARGS__)); \

(result) = String::NewFromUtf8((isolate), v).As<Value>(); \

break; \

} \

case SQLITE_NULL: { \

(result) = Null((isolate)); \

break; \

} \

case SQLITE_BLOB: { \

size_t size = \

static_cast<size_t>(sqlite3_##from##_bytes(__VA_ARGS__)); \

auto data = reinterpret_cast<const uint8_t*>( \

sqlite3_##from##_blob(__VA_ARGS__)); \

auto store = ArrayBuffer::NewBackingStore( \

(isolate), size, BackingStoreInitializationMode::kUninitialized); \

memcpy(store->Data(), data, size); \

auto ab = ArrayBuffer::New((isolate), std::move(store)); \

(result) = Uint8Array::New(ab, 0, size); \

break; \

} \

default: \

UNREACHABLE("Bad SQLite value"); \

} \

} while (0)

namespace {

Local<DictionaryTemplate> getLazyIterTemplate(Environment* env) {

auto iter_template = env->iter_template();

if (iter_template.IsEmpty()) {

static constexpr std::string_view iter_keys[] = {"done", "value"};

iter_template = DictionaryTemplate::New(env->isolate(), iter_keys);

env->set_iter_template(iter_template);

}

return iter_template;

}

} // namespace

inline MaybeLocal<Object> CreateSQLiteError(Isolate* isolate,

const char* message) {

Local<String> js_msg;

Local<Object> e;

Environment* env = Environment::GetCurrent(isolate);

if (!String::NewFromUtf8(isolate, message).ToLocal(&js_msg) ||

!Exception::Error(js_msg)

->ToObject(isolate->GetCurrentContext())

.ToLocal(&e) ||

e->Set(isolate->GetCurrentContext(),

env->code_string(),

env->err_sqlite_error_string())

.IsNothing()) {

return MaybeLocal<Object>();

}

return e;

}

inline MaybeLocal<Object> CreateSQLiteError(Isolate* isolate, int errcode) {

const char* errstr = sqlite3_errstr(errcode);

Local<String> js_errmsg;

Local<Object> e;

Environment* env = Environment::GetCurrent(isolate);

if (!String::NewFromUtf8(isolate, errstr).ToLocal(&js_errmsg) ||

!CreateSQLiteError(isolate, errstr).ToLocal(&e) ||

e->Set(env->context(),

env->errcode_string(),

Integer::New(isolate, errcode))

.IsNothing() ||

e->Set(env->context(), env->errstr_string(), js_errmsg).IsNothing()) {

return MaybeLocal<Object>();

}

return e;

}

inline MaybeLocal<Object> CreateSQLiteError(Isolate* isolate, sqlite3* db) {

int errcode = sqlite3_extended_errcode(db);

const char* errstr = sqlite3_errstr(errcode);

const char* errmsg = sqlite3_errmsg(db);

Local<String> js_errmsg;

Local<Object> e;

Environment* env = Environment::GetCurrent(isolate);

if (!String::NewFromUtf8(isolate, errstr).ToLocal(&js_errmsg) ||

!CreateSQLiteError(isolate, errmsg).ToLocal(&e) ||

e->Set(isolate->GetCurrentContext(),

env->errcode_string(),

Integer::New(isolate, errcode))

.IsNothing() ||

e->Set(isolate->GetCurrentContext(), env->errstr_string(), js_errmsg)

.IsNothing()) {

return MaybeLocal<Object>();

}

return e;

}

void JSValueToSQLiteResult(Isolate* isolate,

sqlite3_context* ctx,

Local<Value> value) {

if (value->IsNullOrUndefined()) {

sqlite3_result_null(ctx);

} else if (value->IsNumber()) {

sqlite3_result_double(ctx, value.As<Number>()->Value());

} else if (value->IsString()) {

Utf8Value val(isolate, value.As<String>());

sqlite3_result_text(ctx, *val, val.length(), SQLITE_TRANSIENT);

} else if (value->IsArrayBufferView()) {

ArrayBufferViewContents<uint8_t> buf(value);

sqlite3_result_blob(ctx, buf.data(), buf.length(), SQLITE_TRANSIENT);

} else if (value->IsBigInt()) {

bool lossless;

int64_t as_int = value.As<BigInt>()->Int64Value(&lossless);

if (!lossless) {

sqlite3_result_error(ctx, "BigInt value is too large for SQLite", -1);

return;

}

sqlite3_result_int64(ctx, as_int);

} else if (value->IsPromise()) {

sqlite3_result_error(

ctx, "Asynchronous user-defined functions are not supported", -1);

} else {

sqlite3_result_error(

ctx,

"Returned JavaScript value cannot be converted to a SQLite value",

-1);

}

}

class DatabaseSync;

inline void THROW_ERR_SQLITE_ERROR(Isolate* isolate, DatabaseSync* db) {

if (db->ShouldIgnoreSQLiteError()) {

db->SetIgnoreNextSQLiteError(false);

return;

}

Local<Object> e;

if (CreateSQLiteError(isolate, db->Connection()).ToLocal(&e)) {

isolate->ThrowException(e);

}

}

inline void THROW_ERR_SQLITE_ERROR(Isolate* isolate, const char* message) {

Local<Object> e;

if (CreateSQLiteError(isolate, message).ToLocal(&e)) {

isolate->ThrowException(e);

}

}

inline void THROW_ERR_SQLITE_ERROR(Isolate* isolate, int errcode) {

const char* errstr = sqlite3_errstr(errcode);

Environment* env = Environment::GetCurrent(isolate);

Local<Object> error;

if (CreateSQLiteError(isolate, errstr).ToLocal(&error) &&

error

->Set(isolate->GetCurrentContext(),

env->errcode_string(),

Integer::New(isolate, errcode))

.IsJust()) {

isolate->ThrowException(error);

}

}

inline MaybeLocal<Value> NullableSQLiteStringToValue(Isolate* isolate,

const char* str) {

if (str == nullptr) {

return Null(isolate);

}

return String::NewFromUtf8(isolate, str, NewStringType::kInternalized)

.As<Value>();

}

class CustomAggregate {

public:

explicit CustomAggregate(Environment* env,

DatabaseSync* db,

bool use_bigint_args,

Local<Value> start,

Local<Function> step_fn,

Local<Function> inverse_fn,

Local<Function> result_fn)

: env_(env),

db_(db),

use_bigint_args_(use_bigint_args),

start_(env->isolate(), start),

step_fn_(env->isolate(), step_fn),

inverse_fn_(env->isolate(), inverse_fn),

result_fn_(env->isolate(), result_fn) {}

static void xStep(sqlite3_context* ctx, int argc, sqlite3_value** argv) {

xStepBase(ctx, argc, argv, &CustomAggregate::step_fn_);

}

static void xInverse(sqlite3_context* ctx, int argc, sqlite3_value** argv) {

xStepBase(ctx, argc, argv, &CustomAggregate::inverse_fn_);

}

static void xFinal(sqlite3_context* ctx) { xValueBase(ctx, true); }

static void xValue(sqlite3_context* ctx) { xValueBase(ctx, false); }

static void xDestroy(void* self) {

delete static_cast<CustomAggregate*>(self);

}

private:

struct aggregate_data {

Global<Value> value;

bool initialized;

bool is_window;

};

static inline void xStepBase(sqlite3_context* ctx,

int argc,

sqlite3_value** argv,

Global<Function> CustomAggregate::*mptr) {

CustomAggregate* self =

static_cast<CustomAggregate*>(sqlite3_user_data(ctx));

Environment* env = self->env_;

Isolate* isolate = env->isolate();

auto agg = self->GetAggregate(ctx);

if (!agg) {

return;

}

auto recv = Undefined(isolate);

LocalVector<Value> js_argv(isolate);

js_argv.reserve(argc + 1);

js_argv.emplace_back(Local<Value>::New(isolate, agg->value));

for (int i = 0; i < argc; ++i) {

sqlite3_value* value = argv[i];

MaybeLocal<Value> js_val;

SQLITE_VALUE_TO_JS(value, isolate, self->use_bigint_args_, js_val, value);

if (js_val.IsEmpty()) {

// Ignore the SQLite error because a JavaScript exception is pending.

self->db_->SetIgnoreNextSQLiteError(true);

sqlite3_result_error(ctx, "", 0);

return;

}

Local<Value> local;

if (!js_val.ToLocal(&local)) {

// Ignore the SQLite error because a JavaScript exception is pending.

self->db_->SetIgnoreNextSQLiteError(true);

sqlite3_result_error(ctx, "", 0);

return;

}

js_argv.emplace_back(local);

}

Local<Value> ret;

if (!(self->*mptr)

.Get(isolate)

->Call(env->context(), recv, argc + 1, js_argv.data())

.ToLocal(&ret)) {

self->db_->SetIgnoreNextSQLiteError(true);

sqlite3_result_error(ctx, "", 0);

return;

}

agg->value.Reset(isolate, ret);

}

static inline void xValueBase(sqlite3_context* ctx, bool is_final) {

CustomAggregate* self =

static_cast<CustomAggregate*>(sqlite3_user_data(ctx));

Environment* env = self->env_;

Isolate* isolate = env->isolate();

auto agg = self->GetAggregate(ctx);

if (!agg) {

return;

}

if (!is_final) {

agg->is_window = true;

} else if (agg->is_window) {

DestroyAggregateData(ctx);

return;

}

Local<Value> result;

if (!self->result_fn_.IsEmpty()) {

Local<Function> fn =

Local<Function>::New(env->isolate(), self->result_fn_);

Local<Value> js_arg[] = {Local<Value>::New(isolate, agg->value)};

if (!fn->Call(env->context(), Null(isolate), 1, js_arg)

.ToLocal(&result)) {

self->db_->SetIgnoreNextSQLiteError(true);

sqlite3_result_error(ctx, "", 0);

}

} else {

result = Local<Value>::New(isolate, agg->value);

}

if (!result.IsEmpty()) {

JSValueToSQLiteResult(isolate, ctx, result);

}

if (is_final) {

DestroyAggregateData(ctx);

}

}

static void DestroyAggregateData(sqlite3_context* ctx) {

aggregate_data* agg = static_cast<aggregate_data*>(

sqlite3_aggregate_context(ctx, sizeof(aggregate_data)));

CHECK(agg->initialized);

agg->value.Reset();

}

aggregate_data* GetAggregate(sqlite3_context* ctx) {

aggregate_data* agg = static_cast<aggregate_data*>(

sqlite3_aggregate_context(ctx, sizeof(aggregate_data)));

if (!agg->initialized) {

Isolate* isolate = env_->isolate();

Local<Value> start_v = Local<Value>::New(isolate, start_);

if (start_v->IsFunction()) {

auto fn = start_v.As<Function>();

MaybeLocal<Value> retval =

fn->Call(env_->context(), Null(isolate), 0, nullptr);

if (!retval.ToLocal(&start_v)) {

db_->SetIgnoreNextSQLiteError(true);

sqlite3_result_error(ctx, "", 0);

return nullptr;

}

}

agg->value.Reset(env_->isolate(), start_v);

agg->initialized = true;

}

return agg;

}

Environment* env_;

DatabaseSync* db_;

bool use_bigint_args_;

Global<Value> start_;

Global<Function> step_fn_;

Global<Function> inverse_fn_;

Global<Function> result_fn_;

};

class BackupJob : public ThreadPoolWork {

public:

explicit BackupJob(Environment* env,

DatabaseSync* source,

Local<Promise::Resolver> resolver,

std::string source_db,

std::string destination_name,

std::string dest_db,

int pages,

Local<Function> progressFunc)

: ThreadPoolWork(env, "node_sqlite3.BackupJob"),

env_(env),

source_(source),

pages_(pages),

source_db_(std::move(source_db)),

destination_name_(std::move(destination_name)),

dest_db_(std::move(dest_db)) {

resolver_.Reset(env->isolate(), resolver);

progressFunc_.Reset(env->isolate(), progressFunc);

}

void ScheduleBackup() {

Isolate* isolate = env()->isolate();

HandleScope handle_scope(isolate);

backup_status_ = sqlite3_open_v2(

destination_name_.c_str(),

&dest_,

SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_URI,

nullptr);

Local<Promise::Resolver> resolver =

Local<Promise::Resolver>::New(env()->isolate(), resolver_);

if (backup_status_ != SQLITE_OK) {

HandleBackupError(resolver);

return;

}

backup_ = sqlite3_backup_init(

dest_, dest_db_.c_str(), source_->Connection(), source_db_.c_str());

if (backup_ == nullptr) {

HandleBackupError(resolver);

return;

}

this->ScheduleWork();

}

void DoThreadPoolWork() override {

backup_status_ = sqlite3_backup_step(backup_, pages_);

}

void AfterThreadPoolWork(int status) override {

HandleScope handle_scope(env()->isolate());

Local<Promise::Resolver> resolver =

Local<Promise::Resolver>::New(env()->isolate(), resolver_);

if (!(backup_status_ == SQLITE_OK || backup_status_ == SQLITE_DONE ||

backup_status_ == SQLITE_BUSY || backup_status_ == SQLITE_LOCKED)) {

HandleBackupError(resolver, backup_status_);

return;

}

int total_pages = sqlite3_backup_pagecount(backup_);

int remaining_pages = sqlite3_backup_remaining(backup_);

if (remaining_pages != 0) {

Local<Function> fn =

Local<Function>::New(env()->isolate(), progressFunc_);

if (!fn.IsEmpty()) {

Local<Object> progress_info = Object::New(env()->isolate());

if (progress_info

->Set(env()->context(),

env()->total_pages_string(),

Integer::New(env()->isolate(), total_pages))

.IsNothing() ||

progress_info

->Set(env()->context(),

env()->remaining_pages_string(),

Integer::New(env()->isolate(), remaining_pages))

.IsNothing()) {

return;

}

Local<Value> argv[] = {progress_info};

TryCatch try_catch(env()->isolate());

USE(fn->Call(env()->context(), Null(env()->isolate()), 1, argv));

if (try_catch.HasCaught()) {

Finalize();

resolver->Reject(env()->context(), try_catch.Exception()).ToChecked();

return;

}

}

// There's still work to do

this->ScheduleWork();

return;

}

if (backup_status_ != SQLITE_DONE) {

HandleBackupError(resolver);

return;

}

Finalize();

resolver

->Resolve(env()->context(), Integer::New(env()->isolate(), total_pages))

.ToChecked();

}

void Finalize() {

Cleanup();

source_->RemoveBackup(this);

}

void Cleanup() {

if (backup_) {

sqlite3_backup_finish(backup_);

backup_ = nullptr;

}

if (dest_) {

backup_status_ = sqlite3_errcode(dest_);

sqlite3_close_v2(dest_);

dest_ = nullptr;

}

}

private:

void HandleBackupError(Local<Promise::Resolver> resolver) {

Local<Object> e;

if (!CreateSQLiteError(env()->isolate(), dest_).ToLocal(&e)) {

Finalize();

return;

}

Finalize();

resolver->Reject(env()->context(), e).ToChecked();

}

void HandleBackupError(Local<Promise::Resolver> resolver, int errcode) {

Local<Object> e;

if (!CreateSQLiteError(env()->isolate(), errcode).ToLocal(&e)) {

Finalize();

return;

}

Finalize();

resolver->Reject(env()->context(), e).ToChecked();

}

Environment* env() const { return env_; }

Environment* env_;

DatabaseSync* source_;

Global<Promise::Resolver> resolver_;

Global<Function> progressFunc_;

sqlite3* dest_ = nullptr;

sqlite3_backup* backup_ = nullptr;

int pages_;

int backup_status_ = SQLITE_OK;

std::string source_db_;

std::string destination_name_;

std::string dest_db_;

};

UserDefinedFunction::UserDefinedFunction(Environment* env,

Local<Function> fn,

DatabaseSync* db,

bool use_bigint_args)

: env_(env),

fn_(env->isolate(), fn),

db_(db),

use_bigint_args_(use_bigint_args) {}

UserDefinedFunction::~UserDefinedFunction() {}

void UserDefinedFunction::xFunc(sqlite3_context* ctx,

int argc,

sqlite3_value** argv) {

UserDefinedFunction* self =

static_cast<UserDefinedFunction*>(sqlite3_user_data(ctx));

Environment* env = self->env_;

Isolate* isolate = env->isolate();

auto recv = Undefined(isolate);

auto fn = self->fn_.Get(isolate);

LocalVector<Value> js_argv(isolate);

js_argv.reserve(argc);

for (int i = 0; i < argc; ++i) {

sqlite3_value* value = argv[i];

MaybeLocal<Value> js_val = MaybeLocal<Value>();

SQLITE_VALUE_TO_JS(value, isolate, self->use_bigint_args_, js_val, value);

if (js_val.IsEmpty()) {

// Ignore the SQLite error because a JavaScript exception is pending.

self->db_->SetIgnoreNextSQLiteError(true);

sqlite3_result_error(ctx, "", 0);

return;

}

Local<Value> local;

if (!js_val.ToLocal(&local)) {

// Ignore the SQLite error because a JavaScript exception is pending.

self->db_->SetIgnoreNextSQLiteError(true);

sqlite3_result_error(ctx, "", 0);

return;

}

js_argv.emplace_back(local);

}

MaybeLocal<Value> retval =

fn->Call(env->context(), recv, argc, js_argv.data());

Local<Value> result;

if (!retval.ToLocal(&result)) {

// Ignore the SQLite error because a JavaScript exception is pending.

self->db_->SetIgnoreNextSQLiteError(true);

sqlite3_result_error(ctx, "", 0);

return;

}

JSValueToSQLiteResult(isolate, ctx, result);

}

void UserDefinedFunction::xDestroy(void* self) {

delete static_cast<UserDefinedFunction*>(self);

}

DatabaseSync::DatabaseSync(Environment* env,

Local<Object> object,

DatabaseOpenConfiguration&& open_config,

bool open,

bool allow_load_extension)

: BaseObject(env, object), open_config_(std::move(open_config)) {

MakeWeak();

connection_ = nullptr;

allow_load_extension_ = allow_load_extension;

enable_load_extension_ = allow_load_extension;

ignore_next_sqlite_error_ = false;

if (open) {

Open();

}

}

void DatabaseSync::AddBackup(BackupJob* job) {

backups_.insert(job);

}

void DatabaseSync::RemoveBackup(BackupJob* job) {

backups_.erase(job);

}

void DatabaseSync::DeleteSessions() {

// all attached sessions need to be deleted before the database is closed

// https://www.sqlite.org/session/sqlite3session_create.html

for (auto* session : sessions_) {

sqlite3session_delete(session);

}

sessions_.clear();

}

DatabaseSync::~DatabaseSync() {

FinalizeBackups();

if (IsOpen()) {

FinalizeStatements();

DeleteSessions();

sqlite3_close_v2(connection_);

connection_ = nullptr;

}

}

void DatabaseSync::MemoryInfo(MemoryTracker* tracker) const {

// TODO(tniessen): more accurately track the size of all fields

tracker->TrackFieldWithSize(

"open_config", sizeof(open_config_), "DatabaseOpenConfiguration");

}

bool DatabaseSync::Open() {

if (IsOpen()) {

THROW_ERR_INVALID_STATE(env(), "database is already open");

return false;

}

// TODO(cjihrig): Support additional flags.

int default_flags = SQLITE_OPEN_URI;

int flags = open_config_.get_read_only()

? SQLITE_OPEN_READONLY

: SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;

int r = sqlite3_open_v2(open_config_.location().c_str(),

&connection_,

flags | default_flags,

nullptr);

CHECK_ERROR_OR_THROW(env()->isolate(), this, r, SQLITE_OK, false);

r = sqlite3_db_config(connection_,

SQLITE_DBCONFIG_DQS_DML,

static_cast<int>(open_config_.get_enable_dqs()),

nullptr);

CHECK_ERROR_OR_THROW(env()->isolate(), this, r, SQLITE_OK, false);

r = sqlite3_db_config(connection_,

SQLITE_DBCONFIG_DQS_DDL,

static_cast<int>(open_config_.get_enable_dqs()),

nullptr);

CHECK_ERROR_OR_THROW(env()->isolate(), this, r, SQLITE_OK, false);

int foreign_keys_enabled;

r = sqlite3_db_config(

connection_,

SQLITE_DBCONFIG_ENABLE_FKEY,

static_cast<int>(open_config_.get_enable_foreign_keys()),

&foreign_keys_enabled);

CHECK_ERROR_OR_THROW(env()->isolate(), this, r, SQLITE_OK, false);

CHECK_EQ(foreign_keys_enabled, open_config_.get_enable_foreign_keys());

int defensive_enabled;

r = sqlite3_db_config(connection_,

SQLITE_DBCONFIG_DEFENSIVE,

static_cast<int>(open_config_.get_enable_defensive()),

&defensive_enabled);

CHECK_ERROR_OR_THROW(env()->isolate(), this, r, SQLITE_OK, false);

CHECK_EQ(defensive_enabled, open_config_.get_enable_defensive());

sqlite3_busy_timeout(connection_, open_config_.get_timeout());

if (allow_load_extension_) {

if (env()->permission()->enabled()) [[unlikely]] {

THROW_ERR_LOAD_SQLITE_EXTENSION(env(),

"Cannot load SQLite extensions when the "

"permission model is enabled.");

return false;

}

const int load_extension_ret = sqlite3_db_config(

connection_, SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION, 1, nullptr);

CHECK_ERROR_OR_THROW(

env()->isolate(), this, load_extension_ret, SQLITE_OK, false);

}

return true;

}

void DatabaseSync::FinalizeBackups() {

for (auto backup : backups_) {

backup->Cleanup();

}

backups_.clear();

}

void DatabaseSync::FinalizeStatements() {

for (auto stmt : statements_) {

stmt->Finalize();

}

statements_.clear();

}

void DatabaseSync::UntrackStatement(StatementSync* statement) {

auto it = statements_.find(statement);

if (it != statements_.end()) {

statements_.erase(it);

}

}

inline bool DatabaseSync::IsOpen() {

return connection_ != nullptr;

}

inline sqlite3* DatabaseSync::Connection() {

return connection_;

}

void DatabaseSync::SetIgnoreNextSQLiteError(bool ignore) {

ignore_next_sqlite_error_ = ignore;

}

bool DatabaseSync::ShouldIgnoreSQLiteError() {

return ignore_next_sqlite_error_;

}

void DatabaseSync::CreateTagStore(const FunctionCallbackInfo<Value>& args) {

DatabaseSync* db = BaseObject::Unwrap<DatabaseSync>(args.This());

Environment* env = Environment::GetCurrent(args);

if (!db->IsOpen()) {

THROW_ERR_INVALID_STATE(env, "database is not open");

return;

}

int capacity = 1000;

if (args.Length() > 0 && args[0]->IsNumber()) {

capacity = args[0].As<Number>()->Value();

}

BaseObjectPtr<SQLTagStore> session =

SQLTagStore::Create(env, BaseObjectWeakPtr<DatabaseSync>(db), capacity);

if (!session) {

// Handle error if creation failed

THROW_ERR_SQLITE_ERROR(env->isolate(), "Failed to create SQLTagStore");

return;

}

args.GetReturnValue().Set(session->object());

}

std::optional<std::string> ValidateDatabasePath(Environment* env,

Local<Value> path,

const std::string& field_name) {

constexpr auto has_null_bytes = [](std::string_view str) {

return str.find('\0') != std::string_view::npos;

};

if (path->IsString()) {

Utf8Value location(env->isolate(), path.As<String>());

if (!has_null_bytes(location.ToStringView())) {

return location.ToString();

}

} else if (path->IsUint8Array()) {

Local<Uint8Array> buffer = path.As<Uint8Array>();

size_t byteOffset = buffer->ByteOffset();

size_t byteLength = buffer->ByteLength();

auto data =

static_cast<const uint8_t*>(buffer->Buffer()->Data()) + byteOffset;

if (std::find(data, data + byteLength, 0) == data + byteLength) {

return std::string(reinterpret_cast<const char*>(data), byteLength);

}

} else if (path->IsObject()) { // When is URL

auto url = path.As<Object>();

Local<Value> href;

if (url->Get(env->context(), env->href_string()).ToLocal(&href) &&

href->IsString()) {

Utf8Value location_value(env->isolate(), href.As<String>());

auto location = location_value.ToStringView();

if (!has_null_bytes(location)) {

CHECK(ada::can_parse(location));

if (!location.starts_with("file:")) {

THROW_ERR_INVALID_URL_SCHEME(env->isolate());

return std::nullopt;

}

return location_value.ToString();

}

}

}

THROW_ERR_INVALID_ARG_TYPE(env->isolate(),

"The \"%s\" argument must be a string, "

"Uint8Array, or URL without null bytes.",

field_name);

return std::nullopt;

}

void DatabaseSync::New(const FunctionCallbackInfo<Value>& args) {

Environment* env = Environment::GetCurrent(args);

if (!args.IsConstructCall()) {

THROW_ERR_CONSTRUCT_CALL_REQUIRED(env);

return;

}

std::optional<std::string> location =

ValidateDatabasePath(env, args[0], "path");

if (!location.has_value()) {

return;

}

DatabaseOpenConfiguration open_config(std::move(location.value()));

bool open = true;

bool allow_load_extension = false;

if (args.Length() > 1) {

if (!args[1]->IsObject()) {

THROW_ERR_INVALID_ARG_TYPE(env->isolate(),

"The \"options\" argument must be an object.");

return;

}

Local<Object> options = args[1].As<Object>();

Local<String> open_string = FIXED_ONE_BYTE_STRING(env->isolate(), "open");

Local<Value> open_v;

if (!options->Get(env->context(), open_string).ToLocal(&open_v)) {

return;

}

if (!open_v->IsUndefined()) {

if (!open_v->IsBoolean()) {

THROW_ERR_INVALID_ARG_TYPE(

env->isolate(), "The \"options.open\" argument must be a boolean.");

return;

}

open = open_v.As<Boolean>()->Value();

}

Local<String> read_only_string =

FIXED_ONE_BYTE_STRING(env->isolate(), "readOnly");

Local<Value> read_only_v;

if (!options->Get(env->context(), read_only_string).ToLocal(&read_only_v)) {

return;

}

if (!read_only_v->IsUndefined()) {

if (!read_only_v->IsBoolean()) {

THROW_ERR_INVALID_ARG_TYPE(

env->isolate(),

"The \"options.readOnly\" argument must be a boolean.");

return;

}

open_config.set_read_only(read_only_v.As<Boolean>()->Value());

}

Local<String> enable_foreign_keys_string =

FIXED_ONE_BYTE_STRING(env->isolate(), "enableForeignKeyConstraints");

Local<Value> enable_foreign_keys_v;

if (!options->Get(env->context(), enable_foreign_keys_string)

.ToLocal(&enable_foreign_keys_v)) {

return;

}

if (!enable_foreign_keys_v->IsUndefined()) {

if (!enable_foreign_keys_v->IsBoolean()) {

THROW_ERR_INVALID_ARG_TYPE(

env->isolate(),

"The \"options.enableForeignKeyConstraints\" argument must be a "

"boolean.");

return;

}

open_config.set_enable_foreign_keys(

enable_foreign_keys_v.As<Boolean>()->Value());

}

Local<String> enable_dqs_string = FIXED_ONE_BYTE_STRING(

env->isolate(), "enableDoubleQuotedStringLiterals");

Local<Value> enable_dqs_v;

if (!options->Get(env->context(), enable_dqs_string)

.ToLocal(&enable_dqs_v)) {

return;

}

if (!enable_dqs_v->IsUndefined()) {

if (!enable_dqs_v->IsBoolean()) {

THROW_ERR_INVALID_ARG_TYPE(

env->isolate(),

"The \"options.enableDoubleQuotedStringLiterals\" argument must be "

"a boolean.");

return;

}

open_config.set_enable_dqs(enable_dqs_v.As<Boolean>()->Value());

}

Local<String> allow_extension_string =

FIXED_ONE_BYTE_STRING(env->isolate(), "allowExtension");

Local<Value> allow_extension_v;

if (!options->Get(env->context(), allow_extension_string)

.ToLocal(&allow_extension_v)) {

return;

}

if (!allow_extension_v->IsUndefined()) {

if (!allow_extension_v->IsBoolean()) {

THROW_ERR_INVALID_ARG_TYPE(

env->isolate(),

"The \"options.allowExtension\" argument must be a boolean.");

return;

}

allow_load_extension = allow_extension_v.As<Boolean>()->Value();