flingit 0.0.62 → 0.0.65

package/node_modules/better-sqlite3/lib/methods/wrappers.js

@@ -0,0 +1,54 @@
+'use strict';
+const { cppdb } = require('../util');
+
+exports.prepare = function prepare(sql) {
+	return this[cppdb].prepare(sql, this, false);
+};
+
+exports.exec = function exec(sql) {
+	this[cppdb].exec(sql);
+	return this;
+};
+
+exports.close = function close() {
+	this[cppdb].close();
+	return this;
+};
+
+exports.loadExtension = function loadExtension(...args) {
+	this[cppdb].loadExtension(...args);
+	return this;
+};
+
+exports.defaultSafeIntegers = function defaultSafeIntegers(...args) {
+	this[cppdb].defaultSafeIntegers(...args);
+	return this;
+};
+
+exports.unsafeMode = function unsafeMode(...args) {
+	this[cppdb].unsafeMode(...args);
+	return this;
+};
+
+exports.getters = {
+	name: {
+		get: function name() { return this[cppdb].name; },
+		enumerable: true,
+	},
+	open: {
+		get: function open() { return this[cppdb].open; },
+		enumerable: true,
+	},
+	inTransaction: {
+		get: function inTransaction() { return this[cppdb].inTransaction; },
+		enumerable: true,
+	},
+	readonly: {
+		get: function readonly() { return this[cppdb].readonly; },
+		enumerable: true,
+	},
+	memory: {
+		get: function memory() { return this[cppdb].memory; },
+		enumerable: true,
+	},
+};

package/node_modules/better-sqlite3/lib/sqlite-error.js

@@ -0,0 +1,20 @@
+'use strict';
+const descriptor = { value: 'SqliteError', writable: true, enumerable: false, configurable: true };
+
+function SqliteError(message, code) {
+	if (new.target !== SqliteError) {
+		return new SqliteError(message, code);
+	}
+	if (typeof code !== 'string') {
+		throw new TypeError('Expected second argument to be a string');
+	}
+	Error.call(this, message);
+	descriptor.value = '' + message;
+	Object.defineProperty(this, 'message', descriptor);
+	Error.captureStackTrace(this, SqliteError);
+	this.code = code;
+}
+Object.setPrototypeOf(SqliteError, Error);
+Object.setPrototypeOf(SqliteError.prototype, Error.prototype);
+Object.defineProperty(SqliteError.prototype, 'name', descriptor);
+module.exports = SqliteError;

package/node_modules/better-sqlite3/lib/util.js

@@ -0,0 +1,12 @@
+'use strict';
+
+exports.getBooleanOption = (options, key) => {
+	let value = false;
+	if (key in options && typeof (value = options[key]) !== 'boolean') {
+		throw new TypeError(`Expected the "${key}" option to be a boolean`);
+	}
+	return value;
+};
+
+exports.cppdb = Symbol();
+exports.inspect = Symbol.for('nodejs.util.inspect.custom');

package/node_modules/better-sqlite3/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "better-sqlite3",
+  "version": "12.8.0",
+  "description": "The fastest and simplest library for SQLite in Node.js.",
+  "homepage": "http://github.com/WiseLibs/better-sqlite3",
+  "author": "Joshua Wise <joshuathomaswise@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/WiseLibs/better-sqlite3.git"
+  },
+  "main": "lib/index.js",
+  "files": [
+    "binding.gyp",
+    "src/**/*.[ch]pp",
+    "lib/**",
+    "deps/**"
+  ],
+  "engines": {
+    "node": "20.x || 22.x || 23.x || 24.x || 25.x"
+  },
+  "dependencies": {
+    "bindings": "^1.5.0",
+    "prebuild-install": "^7.1.1"
+  },
+  "overrides": {
+    "prebuild": {
+      "node-abi": "^4.25.0"
+    }
+  },
+  "devDependencies": {
+    "chai": "^4.3.8",
+    "cli-color": "^2.0.3",
+    "fs-extra": "^11.1.1",
+    "mocha": "^10.2.0",
+    "nodemark": "^0.3.0",
+    "prebuild": "^13.0.1",
+    "sqlite": "^5.0.1",
+    "sqlite3": "^5.1.6"
+  },
+  "scripts": {
+    "install": "prebuild-install || node-gyp rebuild --release",
+    "build-release": "node-gyp rebuild --release",
+    "build-debug": "node-gyp rebuild --debug",
+    "test": "mocha --exit --slow=75 --timeout=5000",
+    "benchmark": "node benchmark",
+    "download": "bash ./deps/download.sh"
+  },
+  "license": "MIT",
+  "keywords": [
+    "sql",
+    "sqlite",
+    "sqlite3",
+    "transactions",
+    "user-defined functions",
+    "aggregate functions",
+    "window functions",
+    "database"
+  ]
+}

package/node_modules/better-sqlite3/src/addon.cpp

@@ -0,0 +1,47 @@
+struct Addon {
+	explicit Addon(v8::Isolate* isolate) :
+		privileged_info(NULL),
+		next_id(0),
+		cs(isolate) {}
+
+	static void Cleanup(void* ptr) {
+		Addon* addon = static_cast<Addon*>(ptr);
+		for (Database* db : addon->dbs) db->CloseHandles();
+		addon->dbs.clear();
+		delete addon;
+	}
+
+	inline sqlite3_uint64 NextId() {
+		return next_id++;
+	}
+
+	static void ConfigureURI() {
+		static std::once_flag init_flag;
+		std::call_once(init_flag, [](){
+			const char* env = getenv("SQLITE_USE_URI");
+			if (env != NULL) {
+				if (strcmp(env, "1") == 0) {
+					int status = sqlite3_config(SQLITE_CONFIG_URI, 1);
+					assert(status == SQLITE_OK); ((void)status);
+				} else if (strcmp(env, "0") == 0) {
+					int status = sqlite3_config(SQLITE_CONFIG_URI, 0);
+					assert(status == SQLITE_OK); ((void)status);
+				}
+			}
+		});
+	}
+
+	static NODE_METHOD(JS_setErrorConstructor) {
+		REQUIRE_ARGUMENT_FUNCTION(first, v8::Local<v8::Function> SqliteError);
+		OnlyAddon->SqliteError.Reset(OnlyIsolate, SqliteError);
+	}
+
+	v8::Global<v8::Function> Statement;
+	v8::Global<v8::Function> StatementIterator;
+	v8::Global<v8::Function> Backup;
+	v8::Global<v8::Function> SqliteError;
+	NODE_ARGUMENTS_POINTER privileged_info;
+	sqlite3_uint64 next_id;
+	CS cs;
+	std::set<Database*, Database::CompareDatabase> dbs;
+};

package/node_modules/better-sqlite3/src/better_sqlite3.cpp

@@ -0,0 +1,74 @@
+#include <climits>
+#include <cstdio>
+#include <cstring>
+#include <string>
+#include <vector>
+#include <set>
+#include <unordered_map>
+#include <algorithm>
+#include <mutex>
+#include <sqlite3.h>
+#include <node.h>
+#include <node_object_wrap.h>
+#include <node_buffer.h>
+
+struct Addon;
+class Database;
+class Statement;
+class StatementIterator;
+class Backup;
+
+#include "util/macros.cpp"
+#include "util/helpers.cpp"
+#include "util/constants.cpp"
+#include "util/bind-map.cpp"
+#include "util/data-converter.cpp"
+#include "util/data.cpp"
+#if defined(NODE_MODULE_VERSION) && NODE_MODULE_VERSION >= 127
+#include "util/row-builder.cpp"
+#endif
+
+#include "objects/backup.hpp"
+#include "objects/statement.hpp"
+#include "objects/database.hpp"
+#include "addon.cpp"
+#include "objects/statement-iterator.hpp"
+
+#include "util/query-macros.cpp"
+#include "util/custom-function.cpp"
+#include "util/custom-aggregate.cpp"
+#include "util/custom-table.cpp"
+#include "util/binder.cpp"
+
+#include "objects/backup.cpp"
+#include "objects/statement.cpp"
+#include "objects/database.cpp"
+#include "objects/statement-iterator.cpp"
+
+NODE_MODULE_INIT(/* exports, context */) {
+    #if defined(NODE_MODULE_VERSION) && NODE_MODULE_VERSION >= 140
+    // Use Isolate::GetCurrent as stated in deprecation message within v8_context.h 13.9.72320122
+	v8::Isolate* isolate = v8::Isolate::GetCurrent();
+	#else
+	v8::Isolate* isolate = context->GetIsolate();
+	#endif
+	v8::HandleScope scope(isolate);
+	Addon::ConfigureURI();
+
+	// Initialize addon instance.
+	Addon* addon = new Addon(isolate);
+	v8::Local<v8::External> data = v8::External::New(isolate, addon);
+	node::AddEnvironmentCleanupHook(isolate, Addon::Cleanup, addon);
+
+	// Create and export native-backed classes and functions.
+	exports->Set(context, InternalizedFromLatin1(isolate, "Database"), Database::Init(isolate, data)).FromJust();
+	exports->Set(context, InternalizedFromLatin1(isolate, "Statement"), Statement::Init(isolate, data)).FromJust();
+	exports->Set(context, InternalizedFromLatin1(isolate, "StatementIterator"), StatementIterator::Init(isolate, data)).FromJust();
+	exports->Set(context, InternalizedFromLatin1(isolate, "Backup"), Backup::Init(isolate, data)).FromJust();
+	exports->Set(context, InternalizedFromLatin1(isolate, "setErrorConstructor"), v8::FunctionTemplate::New(isolate, Addon::JS_setErrorConstructor, data)->GetFunction(context).ToLocalChecked()).FromJust();
+
+	// Store addon instance data.
+	addon->Statement.Reset(isolate, exports->Get(context, InternalizedFromLatin1(isolate, "Statement")).ToLocalChecked().As<v8::Function>());
+	addon->StatementIterator.Reset(isolate, exports->Get(context, InternalizedFromLatin1(isolate, "StatementIterator")).ToLocalChecked().As<v8::Function>());
+	addon->Backup.Reset(isolate, exports->Get(context, InternalizedFromLatin1(isolate, "Backup")).ToLocalChecked().As<v8::Function>());
+}

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

@@ -0,0 +1,120 @@
+Backup::Backup(
+	Database* db,
+	sqlite3* dest_handle,
+	sqlite3_backup* backup_handle,
+	sqlite3_uint64 id,
+	bool unlink
+) :
+	node::ObjectWrap(),
+	db(db),
+	dest_handle(dest_handle),
+	backup_handle(backup_handle),
+	id(id),
+	alive(true),
+	unlink(unlink) {
+	assert(db != NULL);
+	assert(dest_handle != NULL);
+	assert(backup_handle != NULL);
+	db->AddBackup(this);
+}
+
+Backup::~Backup() {
+	if (alive) db->RemoveBackup(this);
+	CloseHandles();
+}
+
+// Whenever this is used, db->RemoveBackup must be invoked beforehand.
+void Backup::CloseHandles() {
+	if (alive) {
+		alive = false;
+		std::string filename(sqlite3_db_filename(dest_handle, "main"));
+		sqlite3_backup_finish(backup_handle);
+		int status = sqlite3_close(dest_handle);
+		assert(status == SQLITE_OK); ((void)status);
+		if (unlink) remove(filename.c_str());
+	}
+}
+
+INIT(Backup::Init) {
+	v8::Local<v8::FunctionTemplate> t = NewConstructorTemplate(isolate, data, JS_new, "Backup");
+	SetPrototypeMethod(isolate, data, t, "transfer", JS_transfer);
+	SetPrototypeMethod(isolate, data, t, "close", JS_close);
+	return t->GetFunction(OnlyContext).ToLocalChecked();
+}
+
+NODE_METHOD(Backup::JS_new) {
+	UseAddon;
+	if (!addon->privileged_info) return ThrowTypeError("Disabled constructor");
+	assert(info.IsConstructCall());
+	Database* db = Unwrap<Database>(addon->privileged_info->This());
+	REQUIRE_DATABASE_OPEN(db->GetState());
+	REQUIRE_DATABASE_NOT_BUSY(db->GetState());
+
+	v8::Local<v8::Object> database = (*addon->privileged_info)[0].As<v8::Object>();
+	v8::Local<v8::String> attachedName = (*addon->privileged_info)[1].As<v8::String>();
+	v8::Local<v8::String> destFile = (*addon->privileged_info)[2].As<v8::String>();
+	bool unlink = (*addon->privileged_info)[3].As<v8::Boolean>()->Value();
+
+	UseIsolate;
+	sqlite3* dest_handle;
+	v8::String::Utf8Value dest_file(isolate, destFile);
+	v8::String::Utf8Value attached_name(isolate, attachedName);
+	int mask = (SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE);
+
+	if (sqlite3_open_v2(*dest_file, &dest_handle, mask, NULL) != SQLITE_OK) {
+		Database::ThrowSqliteError(addon, dest_handle);
+		int status = sqlite3_close(dest_handle);
+		assert(status == SQLITE_OK); ((void)status);
+		return;
+	}
+
+	sqlite3_extended_result_codes(dest_handle, 1);
+	sqlite3_limit(dest_handle, SQLITE_LIMIT_LENGTH, INT_MAX);
+	sqlite3_backup* backup_handle = sqlite3_backup_init(dest_handle, "main", db->GetHandle(), *attached_name);
+	if (backup_handle == NULL) {
+		Database::ThrowSqliteError(addon, dest_handle);
+		int status = sqlite3_close(dest_handle);
+		assert(status == SQLITE_OK); ((void)status);
+		return;
+	}
+
+	Backup* backup = new Backup(db, dest_handle, backup_handle, addon->NextId(), unlink);
+	backup->Wrap(info.This());
+	SetFrozen(isolate, OnlyContext, info.This(), addon->cs.database, database);
+
+	info.GetReturnValue().Set(info.This());
+}
+
+NODE_METHOD(Backup::JS_transfer) {
+	Backup* backup = Unwrap<Backup>(info.This());
+	REQUIRE_ARGUMENT_INT32(first, int pages);
+	REQUIRE_DATABASE_OPEN(backup->db->GetState());
+	assert(backup->db->GetState()->busy == false);
+	assert(backup->alive == true);
+
+	sqlite3_backup* backup_handle = backup->backup_handle;
+	int status = sqlite3_backup_step(backup_handle, pages) & 0xff;
+
+	Addon* addon = backup->db->GetAddon();
+	if (status == SQLITE_OK || status == SQLITE_DONE || status == SQLITE_BUSY) {
+		int total_pages = sqlite3_backup_pagecount(backup_handle);
+		int remaining_pages = sqlite3_backup_remaining(backup_handle);
+		UseIsolate;
+		UseContext;
+		v8::Local<v8::Object> result = v8::Object::New(isolate);
+		result->Set(ctx, addon->cs.totalPages.Get(isolate), v8::Int32::New(isolate, total_pages)).FromJust();
+		result->Set(ctx, addon->cs.remainingPages.Get(isolate), v8::Int32::New(isolate, remaining_pages)).FromJust();
+		info.GetReturnValue().Set(result);
+		if (status == SQLITE_DONE) backup->unlink = false;
+	} else {
+		Database::ThrowSqliteError(addon, sqlite3_errstr(status), status);
+	}
+}
+
+NODE_METHOD(Backup::JS_close) {
+	Backup* backup = Unwrap<Backup>(info.This());
+	assert(backup->db->GetState()->busy == false);
+	if (backup->alive) backup->db->RemoveBackup(backup);
+	backup->CloseHandles();
+	info.GetReturnValue().Set(info.This());
+}

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

@@ -0,0 +1,36 @@
+class Backup : public node::ObjectWrap {
+public:
+
+	~Backup();
+
+	// Whenever this is used, db->RemoveBackup must be invoked beforehand.
+	void CloseHandles();
+
+	// Used to support ordered containers.
+	static inline bool Compare(Backup const * const a, Backup const * const b) {
+		return a->id < b->id;
+	}
+
+	static INIT(Init);
+
+private:
+
+	explicit Backup(
+		Database* db,
+		sqlite3* dest_handle,
+		sqlite3_backup* backup_handle,
+		sqlite3_uint64 id,
+		bool unlink
+	);
+
+	static NODE_METHOD(JS_new);
+	static NODE_METHOD(JS_transfer);
+	static NODE_METHOD(JS_close);
+
+	Database* const db;
+	sqlite3* const dest_handle;
+	sqlite3_backup* const backup_handle;
+	const sqlite3_uint64 id;
+	bool alive;
+	bool unlink;
+};