@pome-sh/cli 0.1.0 → 0.1.1

package/node_modules/better-sqlite3/src/objects/database.cpp

@@ -1,417 +0,0 @@
-const int Database::MAX_BUFFER_SIZE = (
-	node::Buffer::kMaxLength > INT_MAX
-		? INT_MAX
-		: static_cast<int>(node::Buffer::kMaxLength)
-);
-
-const int Database::MAX_STRING_SIZE = (
-	v8::String::kMaxLength > INT_MAX
-		? INT_MAX
-		: static_cast<int>(v8::String::kMaxLength)
-);
-
-Database::Database(
-	v8::Isolate* isolate,
-	Addon* addon,
-	sqlite3* db_handle,
-	v8::Local<v8::Value> logger
-) :
-	node::ObjectWrap(),
-	db_handle(db_handle),
-	open(true),
-	busy(false),
-	safe_ints(false),
-	unsafe_mode(false),
-	was_js_error(false),
-	has_logger(logger->IsFunction()),
-	iterators(0),
-	addon(addon),
-	logger(isolate, logger),
-	stmts(),
-	backups() {
-	assert(db_handle != NULL);
-	addon->dbs.insert(this);
-}
-
-Database::~Database() {
-	if (open) addon->dbs.erase(this);
-	CloseHandles();
-}
-
-// Whenever this is used, addon->dbs.erase() must be invoked beforehand.
-void Database::CloseHandles() {
-	if (open) {
-		open = false;
-		for (Statement* stmt : stmts) stmt->CloseHandles();
-		for (Backup* backup : backups) backup->CloseHandles();
-		stmts.clear();
-		backups.clear();
-		int status = sqlite3_close(db_handle);
-		assert(status == SQLITE_OK); ((void)status);
-	}
-}
-
-void Database::ThrowDatabaseError() {
-	if (was_js_error) was_js_error = false;
-	else ThrowSqliteError(addon, db_handle);
-}
-
-void Database::ThrowSqliteError(Addon* addon, sqlite3* db_handle) {
-	assert(db_handle != NULL);
-	ThrowSqliteError(addon, sqlite3_errmsg(db_handle), sqlite3_extended_errcode(db_handle));
-}
-
-void Database::ThrowSqliteError(Addon* addon, const char* message, int code) {
-	assert(message != NULL);
-	assert((code & 0xff) != SQLITE_OK);
-	assert((code & 0xff) != SQLITE_ROW);
-	assert((code & 0xff) != SQLITE_DONE);
-	EasyIsolate;
-	v8::Local<v8::Value> args[2] = {
-		StringFromUtf8(isolate, message, -1),
-		addon->cs.Code(isolate, code)
-	};
-	isolate->ThrowException(addon->SqliteError.Get(isolate)
-		->NewInstance(OnlyContext, 2, args)
-		.ToLocalChecked());
-}
-
-// Allows Statements to log their executed SQL.
-bool Database::Log(v8::Isolate* isolate, sqlite3_stmt* handle) {
-	assert(was_js_error == false);
-	if (!has_logger) return false;
-	char* expanded = sqlite3_expanded_sql(handle);
-	v8::Local<v8::Value> arg = StringFromUtf8(isolate, expanded ? expanded : sqlite3_sql(handle), -1);
-	was_js_error = logger.Get(isolate).As<v8::Function>()
-		->Call(OnlyContext, v8::Undefined(isolate), 1, &arg)
-		.IsEmpty();
-	if (expanded) sqlite3_free(expanded);
-	return was_js_error;
-}
-
-bool Database::Deserialize(
-	v8::Local<v8::Object> buffer,
-	Addon* addon,
-	sqlite3* db_handle,
-	bool readonly
-) {
-	size_t length = node::Buffer::Length(buffer);
-	unsigned char* data = (unsigned char*)sqlite3_malloc64(length);
-	unsigned int flags = SQLITE_DESERIALIZE_FREEONCLOSE | SQLITE_DESERIALIZE_RESIZEABLE;
-
-	if (readonly) {
-		flags |= SQLITE_DESERIALIZE_READONLY;
-	}
-	if (length) {
-		if (!data) {
-			ThrowError("Out of memory");
-			return false;
-		}
-		memcpy(data, node::Buffer::Data(buffer), length);
-	}
-
-	int status = sqlite3_deserialize(db_handle, "main", data, length, length, flags);
-	if (status != SQLITE_OK) {
-		ThrowSqliteError(addon, status == SQLITE_ERROR ? "unable to deserialize database" : sqlite3_errstr(status), status);
-		return false;
-	}
-
-	return true;
-}
-
-void Database::FreeSerialization(char* data, void* _) {
-	sqlite3_free(data);
-}
-
-INIT(Database::Init) {
-	v8::Local<v8::FunctionTemplate> t = NewConstructorTemplate(isolate, data, JS_new, "Database");
-	SetPrototypeMethod(isolate, data, t, "prepare", JS_prepare);
-	SetPrototypeMethod(isolate, data, t, "exec", JS_exec);
-	SetPrototypeMethod(isolate, data, t, "backup", JS_backup);
-	SetPrototypeMethod(isolate, data, t, "serialize", JS_serialize);
-	SetPrototypeMethod(isolate, data, t, "function", JS_function);
-	SetPrototypeMethod(isolate, data, t, "aggregate", JS_aggregate);
-	SetPrototypeMethod(isolate, data, t, "table", JS_table);
-	SetPrototypeMethod(isolate, data, t, "loadExtension", JS_loadExtension);
-	SetPrototypeMethod(isolate, data, t, "close", JS_close);
-	SetPrototypeMethod(isolate, data, t, "defaultSafeIntegers", JS_defaultSafeIntegers);
-	SetPrototypeMethod(isolate, data, t, "unsafeMode", JS_unsafeMode);
-	SetPrototypeGetter(isolate, data, t, "open", JS_open);
-	SetPrototypeGetter(isolate, data, t, "inTransaction", JS_inTransaction);
-	return t->GetFunction(OnlyContext).ToLocalChecked();
-}
-
-NODE_METHOD(Database::JS_new) {
-	assert(info.IsConstructCall());
-	REQUIRE_ARGUMENT_STRING(first, v8::Local<v8::String> filename);
-	REQUIRE_ARGUMENT_STRING(second, v8::Local<v8::String> filenameGiven);
-	REQUIRE_ARGUMENT_BOOLEAN(third, bool in_memory);
-	REQUIRE_ARGUMENT_BOOLEAN(fourth, bool readonly);
-	REQUIRE_ARGUMENT_BOOLEAN(fifth, bool must_exist);
-	REQUIRE_ARGUMENT_INT32(sixth, int timeout);
-	REQUIRE_ARGUMENT_ANY(seventh, v8::Local<v8::Value> logger);
-	REQUIRE_ARGUMENT_ANY(eighth, v8::Local<v8::Value> buffer);
-
-	UseAddon;
-	UseIsolate;
-	sqlite3* db_handle;
-	v8::String::Utf8Value utf8(isolate, filename);
-	int mask = readonly ? SQLITE_OPEN_READONLY
-		: must_exist ? SQLITE_OPEN_READWRITE
-		: (SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE);
-
-	if (sqlite3_open_v2(*utf8, &db_handle, mask, NULL) != SQLITE_OK) {
-		ThrowSqliteError(addon, db_handle);
-		int status = sqlite3_close(db_handle);
-		assert(status == SQLITE_OK); ((void)status);
-		return;
-	}
-
-	assert(sqlite3_db_mutex(db_handle) == NULL);
-	sqlite3_extended_result_codes(db_handle, 1);
-	sqlite3_busy_timeout(db_handle, timeout);
-	sqlite3_limit(db_handle, SQLITE_LIMIT_LENGTH, MAX_BUFFER_SIZE < MAX_STRING_SIZE ? MAX_BUFFER_SIZE : MAX_STRING_SIZE);
-	sqlite3_limit(db_handle, SQLITE_LIMIT_SQL_LENGTH, MAX_STRING_SIZE);
-	int status = sqlite3_db_config(db_handle, SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION, 1, NULL);
-	assert(status == SQLITE_OK); ((void)status);
-	status = sqlite3_db_config(db_handle, SQLITE_DBCONFIG_DEFENSIVE, 1, NULL);
-	assert(status == SQLITE_OK); ((void)status);
-
-	if (node::Buffer::HasInstance(buffer) && !Deserialize(buffer.As<v8::Object>(), addon, db_handle, readonly)) {
-		int status = sqlite3_close(db_handle);
-		assert(status == SQLITE_OK); ((void)status);
-		return;
-	}
-
-	UseContext;
-	Database* db = new Database(isolate, addon, db_handle, logger);
-	db->Wrap(info.This());
-	SetFrozen(isolate, ctx, info.This(), addon->cs.memory, v8::Boolean::New(isolate, in_memory));
-	SetFrozen(isolate, ctx, info.This(), addon->cs.readonly, v8::Boolean::New(isolate, readonly));
-	SetFrozen(isolate, ctx, info.This(), addon->cs.name, filenameGiven);
-
-	info.GetReturnValue().Set(info.This());
-}
-
-NODE_METHOD(Database::JS_prepare) {
-	REQUIRE_ARGUMENT_STRING(first, v8::Local<v8::String> source);
-	REQUIRE_ARGUMENT_OBJECT(second, v8::Local<v8::Object> database);
-	REQUIRE_ARGUMENT_BOOLEAN(third, bool pragmaMode);
-	(void)source;
-	(void)database;
-	(void)pragmaMode;
-	UseAddon;
-	UseIsolate;
-	v8::Local<v8::Function> c = addon->Statement.Get(isolate);
-	addon->privileged_info = &info;
-	v8::MaybeLocal<v8::Object> maybeStatement = c->NewInstance(OnlyContext, 0, NULL);
-	addon->privileged_info = NULL;
-	if (!maybeStatement.IsEmpty()) info.GetReturnValue().Set(maybeStatement.ToLocalChecked());
-}
-
-NODE_METHOD(Database::JS_exec) {
-	Database* db = Unwrap<Database>(info.This());
-	REQUIRE_ARGUMENT_STRING(first, v8::Local<v8::String> source);
-	REQUIRE_DATABASE_OPEN(db);
-	REQUIRE_DATABASE_NOT_BUSY(db);
-	REQUIRE_DATABASE_NO_ITERATORS_UNLESS_UNSAFE(db);
-	db->busy = true;
-
-	UseIsolate;
-	v8::String::Utf8Value utf8(isolate, source);
-	const char* sql = *utf8;
-	const char* tail;
-
-	int status;
-	const bool has_logger = db->has_logger;
-	sqlite3* const db_handle = db->db_handle;
-	sqlite3_stmt* handle;
-
-	for (;;) {
-		while (IS_SKIPPED(*sql)) ++sql;
-		status = sqlite3_prepare_v2(db_handle, sql, -1, &handle, &tail);
-		sql = tail;
-		if (!handle) break;
-		if (has_logger && db->Log(isolate, handle)) {
-			sqlite3_finalize(handle);
-			status = -1;
-			break;
-		}
-		do status = sqlite3_step(handle);
-		while (status == SQLITE_ROW);
-		status = sqlite3_finalize(handle);
-		if (status != SQLITE_OK) break;
-	}
-
-	db->busy = false;
-	if (status != SQLITE_OK) {
-		db->ThrowDatabaseError();
-	}
-}
-
-NODE_METHOD(Database::JS_backup) {
-	REQUIRE_ARGUMENT_OBJECT(first, v8::Local<v8::Object> database);
-	REQUIRE_ARGUMENT_STRING(second, v8::Local<v8::String> attachedName);
-	REQUIRE_ARGUMENT_STRING(third, v8::Local<v8::String> destFile);
-	REQUIRE_ARGUMENT_BOOLEAN(fourth, bool unlink);
-	(void)database;
-	(void)attachedName;
-	(void)destFile;
-	(void)unlink;
-	UseAddon;
-	UseIsolate;
-	v8::Local<v8::Function> c = addon->Backup.Get(isolate);
-	addon->privileged_info = &info;
-	v8::MaybeLocal<v8::Object> maybeBackup = c->NewInstance(OnlyContext, 0, NULL);
-	addon->privileged_info = NULL;
-	if (!maybeBackup.IsEmpty()) info.GetReturnValue().Set(maybeBackup.ToLocalChecked());
-}
-
-NODE_METHOD(Database::JS_serialize) {
-	Database* db = Unwrap<Database>(info.This());
-	REQUIRE_ARGUMENT_STRING(first, v8::Local<v8::String> attachedName);
-	REQUIRE_DATABASE_OPEN(db);
-	REQUIRE_DATABASE_NOT_BUSY(db);
-	REQUIRE_DATABASE_NO_ITERATORS(db);
-
-	UseIsolate;
-	v8::String::Utf8Value attached_name(isolate, attachedName);
-	sqlite3_int64 length = -1;
-	unsigned char* data = sqlite3_serialize(db->db_handle, *attached_name, &length, 0);
-
-	if (!data && length) {
-		ThrowError("Out of memory");
-		return;
-	}
-
-	info.GetReturnValue().Set(
-		SAFE_NEW_BUFFER(isolate, reinterpret_cast<char*>(data), length, FreeSerialization, NULL).ToLocalChecked()
-	);
-}
-
-NODE_METHOD(Database::JS_function) {
-	Database* db = Unwrap<Database>(info.This());
-	REQUIRE_ARGUMENT_FUNCTION(first, v8::Local<v8::Function> fn);
-	REQUIRE_ARGUMENT_STRING(second, v8::Local<v8::String> nameString);
-	REQUIRE_ARGUMENT_INT32(third, int argc);
-	REQUIRE_ARGUMENT_INT32(fourth, int safe_ints);
-	REQUIRE_ARGUMENT_BOOLEAN(fifth, bool deterministic);
-	REQUIRE_ARGUMENT_BOOLEAN(sixth, bool direct_only);
-	REQUIRE_DATABASE_OPEN(db);
-	REQUIRE_DATABASE_NOT_BUSY(db);
-	REQUIRE_DATABASE_NO_ITERATORS(db);
-
-	UseIsolate;
-	v8::String::Utf8Value name(isolate, nameString);
-	int mask = SQLITE_UTF8;
-	if (deterministic) mask |= SQLITE_DETERMINISTIC;
-	if (direct_only) mask |= SQLITE_DIRECTONLY;
-	safe_ints = safe_ints < 2 ? safe_ints : static_cast<int>(db->safe_ints);
-
-	if (sqlite3_create_function_v2(db->db_handle, *name, argc, mask, new CustomFunction(isolate, db, *name, fn, safe_ints), CustomFunction::xFunc, NULL, NULL, CustomFunction::xDestroy) != SQLITE_OK) {
-		db->ThrowDatabaseError();
-	}
-}
-
-NODE_METHOD(Database::JS_aggregate) {
-	Database* db = Unwrap<Database>(info.This());
-	REQUIRE_ARGUMENT_ANY(first, v8::Local<v8::Value> start);
-	REQUIRE_ARGUMENT_FUNCTION(second, v8::Local<v8::Function> step);
-	REQUIRE_ARGUMENT_ANY(third, v8::Local<v8::Value> inverse);
-	REQUIRE_ARGUMENT_ANY(fourth, v8::Local<v8::Value> result);
-	REQUIRE_ARGUMENT_STRING(fifth, v8::Local<v8::String> nameString);
-	REQUIRE_ARGUMENT_INT32(sixth, int argc);
-	REQUIRE_ARGUMENT_INT32(seventh, int safe_ints);
-	REQUIRE_ARGUMENT_BOOLEAN(eighth, bool deterministic);
-	REQUIRE_ARGUMENT_BOOLEAN(ninth, bool direct_only);
-	REQUIRE_DATABASE_OPEN(db);
-	REQUIRE_DATABASE_NOT_BUSY(db);
-	REQUIRE_DATABASE_NO_ITERATORS(db);
-
-	UseIsolate;
-	v8::String::Utf8Value name(isolate, nameString);
-	auto xInverse = inverse->IsFunction() ? CustomAggregate::xInverse : NULL;
-	auto xValue = xInverse ? CustomAggregate::xValue : NULL;
-	int mask = SQLITE_UTF8;
-	if (deterministic) mask |= SQLITE_DETERMINISTIC;
-	if (direct_only) mask |= SQLITE_DIRECTONLY;
-	safe_ints = safe_ints < 2 ? safe_ints : static_cast<int>(db->safe_ints);
-
-	if (sqlite3_create_window_function(db->db_handle, *name, argc, mask, new CustomAggregate(isolate, db, *name, start, step, inverse, result, safe_ints), CustomAggregate::xStep, CustomAggregate::xFinal, xValue, xInverse, CustomAggregate::xDestroy) != SQLITE_OK) {
-		db->ThrowDatabaseError();
-	}
-}
-
-NODE_METHOD(Database::JS_table) {
-	Database* db = Unwrap<Database>(info.This());
-	REQUIRE_ARGUMENT_FUNCTION(first, v8::Local<v8::Function> factory);
-	REQUIRE_ARGUMENT_STRING(second, v8::Local<v8::String> nameString);
-	REQUIRE_ARGUMENT_BOOLEAN(third, bool eponymous);
-	REQUIRE_DATABASE_OPEN(db);
-	REQUIRE_DATABASE_NOT_BUSY(db);
-	REQUIRE_DATABASE_NO_ITERATORS(db);
-
-	UseIsolate;
-	v8::String::Utf8Value name(isolate, nameString);
-	sqlite3_module* module = eponymous ? &CustomTable::EPONYMOUS_MODULE : &CustomTable::MODULE;
-
-	db->busy = true;
-	if (sqlite3_create_module_v2(db->db_handle, *name, module, new CustomTable(isolate, db, *name, factory), CustomTable::Destructor) != SQLITE_OK) {
-		db->ThrowDatabaseError();
-	}
-	db->busy = false;
-}
-
-NODE_METHOD(Database::JS_loadExtension) {
-	Database* db = Unwrap<Database>(info.This());
-	v8::Local<v8::String> entryPoint;
-	REQUIRE_ARGUMENT_STRING(first, v8::Local<v8::String> filename);
-	if (info.Length() > 1) { REQUIRE_ARGUMENT_STRING(second, entryPoint); }
-	REQUIRE_DATABASE_OPEN(db);
-	REQUIRE_DATABASE_NOT_BUSY(db);
-	REQUIRE_DATABASE_NO_ITERATORS(db);
-	UseIsolate;
-	char* error;
-	int status = sqlite3_load_extension(
-		db->db_handle,
-		*v8::String::Utf8Value(isolate, filename),
-		entryPoint.IsEmpty() ? NULL : *v8::String::Utf8Value(isolate, entryPoint),
-		&error
-	);
-	if (status != SQLITE_OK) {
-		ThrowSqliteError(db->addon, error, status);
-	}
-	sqlite3_free(error);
-}
-
-NODE_METHOD(Database::JS_close) {
-	Database* db = Unwrap<Database>(info.This());
-	if (db->open) {
-		REQUIRE_DATABASE_NOT_BUSY(db);
-		REQUIRE_DATABASE_NO_ITERATORS(db);
-		db->addon->dbs.erase(db);
-		db->CloseHandles();
-	}
-}
-
-NODE_METHOD(Database::JS_defaultSafeIntegers) {
-	Database* db = Unwrap<Database>(info.This());
-	if (info.Length() == 0) db->safe_ints = true;
-	else { REQUIRE_ARGUMENT_BOOLEAN(first, db->safe_ints); }
-}
-
-NODE_METHOD(Database::JS_unsafeMode) {
-	Database* db = Unwrap<Database>(info.This());
-	if (info.Length() == 0) db->unsafe_mode = true;
-	else { REQUIRE_ARGUMENT_BOOLEAN(first, db->unsafe_mode); }
-	sqlite3_db_config(db->db_handle, SQLITE_DBCONFIG_DEFENSIVE, static_cast<int>(!db->unsafe_mode), NULL);
-}
-
-NODE_GETTER(Database::JS_open) {
-	info.GetReturnValue().Set(Unwrap<Database>(PROPERTY_HOLDER(info))->open);
-}
-
-NODE_GETTER(Database::JS_inTransaction) {
-	Database* db = Unwrap<Database>(PROPERTY_HOLDER(info));
-	info.GetReturnValue().Set(db->open && !static_cast<bool>(sqlite3_get_autocommit(db->db_handle)));
-}

package/node_modules/better-sqlite3/src/objects/database.hpp

@@ -1,103 +0,0 @@
-class Database : public node::ObjectWrap {
-public:
-
-	~Database();
-
-	// Whenever this is used, addon->dbs.erase() must be invoked beforehand.
-	void CloseHandles();
-
-	// Used to support ordered containers.
-	class CompareDatabase { public:
-		inline bool operator() (Database const * const a, Database const * const b) const {
-			return a < b;
-		}
-	};
-	class CompareStatement { public:
-		inline bool operator() (Statement const * const a, Statement const * const b) const {
-			return Statement::Compare(a, b);
-		}
-	};
-	class CompareBackup { public:
-		inline bool operator() (Backup const * const a, Backup const * const b) const {
-			return Backup::Compare(a, b);
-		}
-	};
-
-	// Proper error handling logic for when an sqlite3 operation fails.
-	void ThrowDatabaseError();
-	static void ThrowSqliteError(Addon* addon, sqlite3* db_handle);
-	static void ThrowSqliteError(Addon* addon, const char* message, int code);
-
-	// Allows Statements to log their executed SQL.
-	bool Log(v8::Isolate* isolate, sqlite3_stmt* handle);
-
-	// Allow Statements to manage themselves when created and garbage collected.
-	inline void AddStatement(Statement* stmt) { stmts.insert(stmts.end(), stmt); }
-	inline void RemoveStatement(Statement* stmt) { stmts.erase(stmt); }
-
-	// Allow Backups to manage themselves when created and garbage collected.
-	inline void AddBackup(Backup* backup) { backups.insert(backups.end(), backup); }
-	inline void RemoveBackup(Backup* backup) { backups.erase(backup); }
-
-	// A view for Statements to see and modify Database state.
-	// The order of these fields must exactly match their actual order.
-	struct State {
-		const bool open;
-		bool busy;
-		const bool safe_ints;
-		const bool unsafe_mode;
-		bool was_js_error;
-		const bool has_logger;
-		unsigned short iterators;
-		Addon* const addon;
-	};
-
-	inline State* GetState() { return reinterpret_cast<State*>(&open); }
-	inline sqlite3* GetHandle() { return db_handle; }
-	inline Addon* GetAddon() { return addon; }
-
-	static INIT(Init);
-
-private:
-
-	explicit Database(
-		v8::Isolate* isolate,
-		Addon* addon,
-		sqlite3* db_handle,
-		v8::Local<v8::Value> logger
-	);
-
-	static NODE_METHOD(JS_new);
-	static NODE_METHOD(JS_prepare);
-	static NODE_METHOD(JS_exec);
-	static NODE_METHOD(JS_backup);
-	static NODE_METHOD(JS_serialize);
-	static NODE_METHOD(JS_function);
-	static NODE_METHOD(JS_aggregate);
-	static NODE_METHOD(JS_table);
-	static NODE_METHOD(JS_loadExtension);
-	static NODE_METHOD(JS_close);
-	static NODE_METHOD(JS_defaultSafeIntegers);
-	static NODE_METHOD(JS_unsafeMode);
-	static NODE_GETTER(JS_open);
-	static NODE_GETTER(JS_inTransaction);
-
-	static bool Deserialize(v8::Local<v8::Object> buffer, Addon* addon, sqlite3* db_handle, bool readonly);
-	static void FreeSerialization(char* data, void* _);
-
-	static const int MAX_BUFFER_SIZE;
-	static const int MAX_STRING_SIZE;
-
-	sqlite3* const db_handle;
-	bool open;
-	bool busy;
-	bool safe_ints;
-	bool unsafe_mode;
-	bool was_js_error;
-	const bool has_logger;
-	unsigned short iterators;
-	Addon* const addon;
-	const v8::Global<v8::Value> logger;
-	std::set<Statement*, CompareStatement> stmts;
-	std::set<Backup*, CompareBackup> backups;
-};

package/node_modules/better-sqlite3/src/objects/statement-iterator.cpp

@@ -1,113 +0,0 @@
-StatementIterator::StatementIterator(Statement* stmt, bool bound) :
-	node::ObjectWrap(),
-	stmt(stmt),
-	handle(stmt->handle),
-	db_state(stmt->db->GetState()),
-	bound(bound),
-	safe_ints(stmt->safe_ints),
-	mode(stmt->mode),
-	alive(true),
-	logged(!db_state->has_logger) {
-	assert(stmt != NULL);
-	assert(handle != NULL);
-	assert(stmt->bound == bound);
-	assert(stmt->alive == true);
-	assert(stmt->locked == false);
-	assert(db_state->iterators < USHRT_MAX);
-	stmt->locked = true;
-	db_state->iterators += 1;
-}
-
-// The ~Statement destructor currently covers any state this object creates.
-// Additionally, we actually DON'T want to revert stmt->locked or db_state
-// ->iterators in this destructor, to ensure deterministic database access.
-StatementIterator::~StatementIterator() {}
-
-void StatementIterator::Next(NODE_ARGUMENTS info) {
-	assert(alive == true);
-	db_state->busy = true;
-	if (!logged) {
-		logged = true;
-		if (stmt->db->Log(OnlyIsolate, handle)) {
-			db_state->busy = false;
-			Throw();
-			return;
-		}
-	}
-	int status = sqlite3_step(handle);
-	db_state->busy = false;
-	if (status == SQLITE_ROW) {
-		UseIsolate;
-		UseContext;
-		info.GetReturnValue().Set(
-			NewRecord(isolate, ctx, Data::GetRowJS(isolate, ctx, handle, safe_ints, mode), db_state->addon, false)
-		);
-	} else {
-		if (status == SQLITE_DONE) Return(info);
-		else Throw();
-	}
-}
-
-void StatementIterator::Return(NODE_ARGUMENTS info) {
-	Cleanup();
-	STATEMENT_RETURN_LOGIC(DoneRecord(OnlyIsolate, db_state->addon));
-}
-
-void StatementIterator::Throw() {
-	Cleanup();
-	Database* db = stmt->db;
-	STATEMENT_THROW_LOGIC();
-}
-
-void StatementIterator::Cleanup() {
-	assert(alive == true);
-	alive = false;
-	stmt->locked = false;
-	db_state->iterators -= 1;
-	sqlite3_reset(handle);
-}
-
-INIT(StatementIterator::Init) {
-	v8::Local<v8::FunctionTemplate> t = NewConstructorTemplate(isolate, data, JS_new, "StatementIterator");
-	SetPrototypeMethod(isolate, data, t, "next", JS_next);
-	SetPrototypeMethod(isolate, data, t, "return", JS_return);
-	SetPrototypeSymbolMethod(isolate, data, t, v8::Symbol::GetIterator(isolate), JS_symbolIterator);
-	return t->GetFunction(OnlyContext).ToLocalChecked();
-}
-
-NODE_METHOD(StatementIterator::JS_new) {
-	UseAddon;
-	if (!addon->privileged_info) return ThrowTypeError("Disabled constructor");
-	assert(info.IsConstructCall());
-
-	StatementIterator* iter;
-	{
-		NODE_ARGUMENTS info = *addon->privileged_info;
-		STATEMENT_START_LOGIC(REQUIRE_STATEMENT_RETURNS_DATA, DOES_ADD_ITERATOR);
-		iter = new StatementIterator(stmt, bound);
-	}
-	UseIsolate;
-	UseContext;
-	iter->Wrap(info.This());
-	SetFrozen(isolate, ctx, info.This(), addon->cs.statement, addon->privileged_info->This());
-
-	info.GetReturnValue().Set(info.This());
-}
-
-NODE_METHOD(StatementIterator::JS_next) {
-	StatementIterator* iter = Unwrap<StatementIterator>(info.This());
-	REQUIRE_DATABASE_NOT_BUSY(iter->db_state);
-	if (iter->alive) iter->Next(info);
-	else info.GetReturnValue().Set(DoneRecord(OnlyIsolate, iter->db_state->addon));
-}
-
-NODE_METHOD(StatementIterator::JS_return) {
-	StatementIterator* iter = Unwrap<StatementIterator>(info.This());
-	REQUIRE_DATABASE_NOT_BUSY(iter->db_state);
-	if (iter->alive) iter->Return(info);
-	else info.GetReturnValue().Set(DoneRecord(OnlyIsolate, iter->db_state->addon));
-}
-
-NODE_METHOD(StatementIterator::JS_symbolIterator) {
-	info.GetReturnValue().Set(info.This());
-}

package/node_modules/better-sqlite3/src/objects/statement-iterator.hpp

@@ -1,50 +0,0 @@
-class StatementIterator : public node::ObjectWrap {
-public:
-
-	// The ~Statement destructor currently covers any state this object creates.
-	// Additionally, we actually DON'T want to revert stmt->locked or db_state
-	// ->iterators in this destructor, to ensure deterministic database access.
-	~StatementIterator();
-
-	static INIT(Init);
-
-private:
-
-	explicit StatementIterator(Statement* stmt, bool bound);
-
-	void Next(NODE_ARGUMENTS info);
-	void Return(NODE_ARGUMENTS info);
-	void Throw();
-	void Cleanup();
-
-	static inline v8::Local<v8::Object> NewRecord(
-		v8::Isolate* isolate,
-		v8::Local<v8::Context> ctx,
-		v8::Local<v8::Value> value,
-		Addon* addon,
-		bool done
-	) {
-		v8::Local<v8::Object> record = v8::Object::New(isolate);
-		record->Set(ctx, addon->cs.value.Get(isolate), value).FromJust();
-		record->Set(ctx, addon->cs.done.Get(isolate), v8::Boolean::New(isolate, done)).FromJust();
-		return record;
-	}
-
-	static inline v8::Local<v8::Object> DoneRecord(v8::Isolate* isolate, Addon* addon) {
-		return NewRecord(isolate, OnlyContext, v8::Undefined(isolate), addon, true);
-	}
-
-	static NODE_METHOD(JS_new);
-	static NODE_METHOD(JS_next);
-	static NODE_METHOD(JS_return);
-	static NODE_METHOD(JS_symbolIterator);
-
-	Statement* const stmt;
-	sqlite3_stmt* const handle;
-	Database::State* const db_state;
-	const bool bound;
-	const bool safe_ints;
-	const char mode;
-	bool alive;
-	bool logged;
-};