pi-para 0.7.8 → 0.7.10

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

@@ -0,0 +1,195 @@
+'use strict';
+const { cppdb } = require('../util');
+
+module.exports = function defineTable(name, factory) {
+	// Validate arguments
+	if (typeof name !== 'string') throw new TypeError('Expected first argument to be a string');
+	if (!name) throw new TypeError('Virtual table module name cannot be an empty string');
+
+	// Determine whether the module is eponymous-only or not
+	let eponymous = false;
+	if (typeof factory === 'object' && factory !== null) {
+		eponymous = true;
+		factory = defer(parseTableDefinition(factory, 'used', name));
+	} else {
+		if (typeof factory !== 'function') throw new TypeError('Expected second argument to be a function or a table definition object');
+		factory = wrapFactory(factory);
+	}
+
+	this[cppdb].table(factory, name, eponymous);
+	return this;
+};
+
+function wrapFactory(factory) {
+	return function virtualTableFactory(moduleName, databaseName, tableName, ...args) {
+		const thisObject = {
+			module: moduleName,
+			database: databaseName,
+			table: tableName,
+		};
+
+		// Generate a new table definition by invoking the factory
+		const def = apply.call(factory, thisObject, args);
+		if (typeof def !== 'object' || def === null) {
+			throw new TypeError(`Virtual table module "${moduleName}" did not return a table definition object`);
+		}
+
+		return parseTableDefinition(def, 'returned', moduleName);
+	};
+}
+
+function parseTableDefinition(def, verb, moduleName) {
+	// Validate required properties
+	if (!hasOwnProperty.call(def, 'rows')) {
+		throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "rows" property`);
+	}
+	if (!hasOwnProperty.call(def, 'columns')) {
+		throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "columns" property`);
+	}
+
+	// Validate "rows" property
+	const rows = def.rows;
+	if (typeof rows !== 'function' || Object.getPrototypeOf(rows) !== GeneratorFunctionPrototype) {
+		throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "rows" property (should be a generator function)`);
+	}
+
+	// Validate "columns" property
+	let columns = def.columns;
+	if (!Array.isArray(columns) || !isStringArray(columns = [...columns])) {
+		throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "columns" property (should be an array of strings)`);
+	}
+	if (columns.length !== new Set(columns).size) {
+		throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate column names`);
+	}
+	if (!columns.length) {
+		throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with zero columns`);
+	}
+
+	// Validate "parameters" property
+	let parameters;
+	if (hasOwnProperty.call(def, 'parameters')) {
+		parameters = def.parameters;
+		if (!Array.isArray(parameters) || !isStringArray(parameters = [...parameters])) {
+			throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "parameters" property (should be an array of strings)`);
+		}
+	} else {
+		parameters = inferParameters(rows);
+	}
+	if (parameters.length !== new Set(parameters).size) {
+		throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate parameter names`);
+	}
+	if (parameters.length > 32) {
+		throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with more than the maximum number of 32 parameters`);
+	}
+	for (const parameter of parameters) {
+		if (columns.includes(parameter)) {
+			throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with column "${parameter}" which was ambiguously defined as both a column and parameter`);
+		}
+	}
+
+	// Validate "safeIntegers" option
+	let safeIntegers = 2;
+	if (hasOwnProperty.call(def, 'safeIntegers')) {
+		const bool = def.safeIntegers;
+		if (typeof bool !== 'boolean') {
+			throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "safeIntegers" property (should be a boolean)`);
+		}
+		safeIntegers = +bool;
+	}
+
+	// Validate "directOnly" option
+	let directOnly = false;
+	if (hasOwnProperty.call(def, 'directOnly')) {
+		directOnly = def.directOnly;
+		if (typeof directOnly !== 'boolean') {
+			throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "directOnly" property (should be a boolean)`);
+		}
+	}
+
+	// Generate SQL for the virtual table definition
+	const columnDefinitions = [
+		...parameters.map(identifier).map(str => `${str} HIDDEN`),
+		...columns.map(identifier),
+	];
+	return [
+		`CREATE TABLE x(${columnDefinitions.join(', ')});`,
+		wrapGenerator(rows, new Map(columns.map((x, i) => [x, parameters.length + i])), moduleName),
+		parameters,
+		safeIntegers,
+		directOnly,
+	];
+}
+
+function wrapGenerator(generator, columnMap, moduleName) {
+	return function* virtualTable(...args) {
+		/*
+			We must defensively clone any buffers in the arguments, because
+			otherwise the generator could mutate one of them, which would cause
+			us to return incorrect values for hidden columns, potentially
+			corrupting the database.
+		 */
+		const output = args.map(x => Buffer.isBuffer(x) ? Buffer.from(x) : x);
+		for (let i = 0; i < columnMap.size; ++i) {
+			output.push(null); // Fill with nulls to prevent gaps in array (v8 optimization)
+		}
+		for (const row of generator(...args)) {
+			if (Array.isArray(row)) {
+				extractRowArray(row, output, columnMap.size, moduleName);
+				yield output;
+			} else if (typeof row === 'object' && row !== null) {
+				extractRowObject(row, output, columnMap, moduleName);
+				yield output;
+			} else {
+				throw new TypeError(`Virtual table module "${moduleName}" yielded something that isn't a valid row object`);
+			}
+		}
+	};
+}
+
+function extractRowArray(row, output, columnCount, moduleName) {
+	if (row.length !== columnCount) {
+		throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an incorrect number of columns`);
+	}
+	const offset = output.length - columnCount;
+	for (let i = 0; i < columnCount; ++i) {
+		output[i + offset] = row[i];
+	}
+}
+
+function extractRowObject(row, output, columnMap, moduleName) {
+	let count = 0;
+	for (const key of Object.keys(row)) {
+		const index = columnMap.get(key);
+		if (index === undefined) {
+			throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an undeclared column "${key}"`);
+		}
+		output[index] = row[key];
+		count += 1;
+	}
+	if (count !== columnMap.size) {
+		throw new TypeError(`Virtual table module "${moduleName}" yielded a row with missing columns`);
+	}
+}
+
+function inferParameters({ length }) {
+	if (!Number.isInteger(length) || length < 0) {
+		throw new TypeError('Expected function.length to be a positive integer');
+	}
+	const params = [];
+	for (let i = 0; i < length; ++i) {
+		params.push(`$${i + 1}`);
+	}
+	return params;
+}
+
+const { hasOwnProperty } = Object.prototype;
+const { apply } = Function.prototype;
+const GeneratorFunctionPrototype = Object.getPrototypeOf(function*(){});
+const identifier = str => `"${str.replace(/"/g, '""')}"`;
+const defer = x => () => x;
+const isStringArray = (arr) => {
+	for (let i = 0; i < arr.length; ++i) {
+		if (typeof arr[i] !== 'string') return false;
+	}
+	return true;
+};

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

@@ -0,0 +1,78 @@
+'use strict';
+const { cppdb } = require('../util');
+const controllers = new WeakMap();
+
+module.exports = function transaction(fn) {
+	if (typeof fn !== 'function') throw new TypeError('Expected first argument to be a function');
+
+	const db = this[cppdb];
+	const controller = getController(db, this);
+	const { apply } = Function.prototype;
+
+	// Each version of the transaction function has these same properties
+	const properties = {
+		default: { value: wrapTransaction(apply, fn, db, controller.default) },
+		deferred: { value: wrapTransaction(apply, fn, db, controller.deferred) },
+		immediate: { value: wrapTransaction(apply, fn, db, controller.immediate) },
+		exclusive: { value: wrapTransaction(apply, fn, db, controller.exclusive) },
+		database: { value: this, enumerable: true },
+	};
+
+	Object.defineProperties(properties.default.value, properties);
+	Object.defineProperties(properties.deferred.value, properties);
+	Object.defineProperties(properties.immediate.value, properties);
+	Object.defineProperties(properties.exclusive.value, properties);
+
+	// Return the default version of the transaction function
+	return properties.default.value;
+};
+
+// Return the database's cached transaction controller, or create a new one
+const getController = (db, self) => {
+	let controller = controllers.get(db);
+	if (!controller) {
+		const shared = {
+			commit: db.prepare('COMMIT', self, false, false),
+			rollback: db.prepare('ROLLBACK', self, false, false),
+			savepoint: db.prepare('SAVEPOINT `\t_bs3.\t`', self, false, false),
+			release: db.prepare('RELEASE `\t_bs3.\t`', self, false, false),
+			rollbackTo: db.prepare('ROLLBACK TO `\t_bs3.\t`', self, false, false),
+		};
+		controllers.set(db, controller = {
+			default: Object.assign({ begin: db.prepare('BEGIN', self, false, false) }, shared),
+			deferred: Object.assign({ begin: db.prepare('BEGIN DEFERRED', self, false, false) }, shared),
+			immediate: Object.assign({ begin: db.prepare('BEGIN IMMEDIATE', self, false, false) }, shared),
+			exclusive: Object.assign({ begin: db.prepare('BEGIN EXCLUSIVE', self, false, false) }, shared),
+		});
+	}
+	return controller;
+};
+
+// Return a new transaction function by wrapping the given function
+const wrapTransaction = (apply, fn, db, { begin, commit, rollback, savepoint, release, rollbackTo }) => function sqliteTransaction() {
+	let before, after, undo;
+	if (db.inTransaction) {
+		before = savepoint;
+		after = release;
+		undo = rollbackTo;
+	} else {
+		before = begin;
+		after = commit;
+		undo = rollback;
+	}
+	before.run();
+	try {
+		const result = apply.call(fn, this, arguments);
+		if (result && typeof result.then === 'function') {
+			throw new TypeError('Transaction function cannot return a promise');
+		}
+		after.run();
+		return result;
+	} catch (ex) {
+		if (db.inTransaction) {
+			undo.run();
+			if (undo !== rollback) after.run();
+		}
+		throw ex;
+	}
+};

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, 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,25 @@
+'use strict';
+
+class SqliteError extends Error {
+	constructor(message, code) {
+		if (typeof code !== 'string') {
+			throw new TypeError('Expected second argument to be a string');
+		}
+
+		super('' + message);
+		this.code = code;
+
+		if (typeof Error.captureStackTrace === 'function') {
+			Error.captureStackTrace(this, SqliteError);
+		}
+	}
+}
+
+Object.defineProperty(SqliteError.prototype, 'name', {
+	value: 'SqliteError',
+	writable: true,
+	enumerable: false,
+	configurable: true,
+});
+
+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/lib/win32-arm64.js

@@ -0,0 +1,3 @@
+'use strict';
+module.exports = require('./database')(() => require('../prebuilds/win32-arm64.node'), false);
+module.exports.SqliteError = require('./sqlite-error');

package/node_modules/better-sqlite3/lib/win32-x64.js

@@ -0,0 +1,3 @@
+'use strict';
+module.exports = require('./database')(() => require('../prebuilds/win32-x64.node'), false);
+module.exports.SqliteError = require('./sqlite-error');

package/node_modules/better-sqlite3/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "better-sqlite3",
+  "version": "13.0.3",
+  "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",
+  "exports": {
+    ".": "./lib/index.js",
+    "./linux-x64": "./lib/linux-x64.js",
+    "./linux-arm64": "./lib/linux-arm64.js",
+    "./linuxmusl-x64": "./lib/linuxmusl-x64.js",
+    "./linuxmusl-arm64": "./lib/linuxmusl-arm64.js",
+    "./darwin-x64": "./lib/darwin-x64.js",
+    "./darwin-arm64": "./lib/darwin-arm64.js",
+    "./win32-x64": "./lib/win32-x64.js",
+    "./win32-arm64": "./lib/win32-arm64.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "binding.gyp",
+    "src/**/*.[ch]pp",
+    "lib/**",
+    "deps/**",
+    "prebuilds/**"
+  ],
+  "gypfile": false,
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "node-addon-api": "^8.0.0"
+  },
+  "devDependencies": {
+    "chai": "^4.3.8",
+    "cli-color": "^2.0.3",
+    "fs-extra": "^11.1.1",
+    "mocha": "^11.7.5",
+    "node-gyp": "^10.3.1",
+    "nodemark": "^0.3.0",
+    "sqlite": "^5.0.1",
+    "sqlite3": "^5.1.6"
+  },
+  "scripts": {
+    "build-release": "node-gyp clean && node-gyp rebuild --release --force_build=1",
+    "build-debug": "node-gyp clean && node-gyp rebuild --debug --force_build=1",
+    "test": "mocha --exit --slow=75 --timeout=5000",
+    "benchmark": "node benchmark",
+    "download": "bash ./deps/download.sh",
+    "clean": "rm -rf node_modules build prebuilds"
+  },
+  "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,59 @@
+struct Addon {
+	explicit Addon(Napi::Env env) :
+		privileged_info(NULL),
+		next_id(0),
+		cs(env) {}
+
+	static void Cleanup(Addon* addon) {
+		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_initialize) {
+		REQUIRE_ARGUMENT_FUNCTION(first, Napi::Function SqliteError);
+		REQUIRE_ARGUMENT_FUNCTION(second, Napi::Function ArrayFactory);
+		REQUIRE_ARGUMENT_FUNCTION(third, Napi::Function ArrayAppender);
+		REQUIRE_ARGUMENT_FUNCTION(fourth, Napi::Function RowFactory);
+		REQUIRE_ARGUMENT_FUNCTION(fifth, Napi::Function RecordFactory);
+		OnlyAddon->SqliteError = Napi::Persistent(SqliteError);
+		OnlyAddon->ArrayFactory = Napi::Persistent(ArrayFactory);
+		OnlyAddon->ArrayAppender = Napi::Persistent(ArrayAppender);
+		OnlyAddon->RowFactory = Napi::Persistent(RowFactory);
+		OnlyAddon->RecordFactory = Napi::Persistent(RecordFactory);
+		return info.Env().Undefined();
+	}
+
+	Napi::FunctionReference Statement;
+	Napi::FunctionReference StatementIterator;
+	Napi::FunctionReference Backup;
+	Napi::FunctionReference SqliteError;
+	Napi::FunctionReference ArrayFactory;
+	Napi::FunctionReference ArrayAppender;
+	Napi::FunctionReference RowFactory;
+	Napi::FunctionReference RecordFactory;
+	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,73 @@
+#include <cassert>
+#include <climits>
+#include <cmath>
+#include <cstdio>
+#include <cstring>
+#include <string>
+#include <vector>
+#include <set>
+#include <random>
+#include <unordered_map>
+#include <algorithm>
+#include <mutex>
+#include <sqlite3.h>
+#include <napi.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/row-builder.hpp"
+#include "objects/backup.hpp"
+#include "objects/statement.hpp"
+#include "objects/database.hpp"
+#include "addon.cpp"
+#include "objects/statement-iterator.hpp"
+
+#include "util/data.cpp"
+#include "util/row-builder.cpp"
+#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"
+
+Napi::Object InitAll(Napi::Env env, Napi::Object exports) {
+	Napi::HandleScope scope(env);
+	Addon::ConfigureURI();
+
+	// Initialize addon instance. The addon is bound to each native-backed class
+	// as callback data (rather than per-environment instance data) so that
+	// multiple copies of the addon can be loaded into a single environment.
+	Addon* addon = new Addon(env);
+	env.AddCleanupHook(Addon::Cleanup, addon);
+
+	// Create and export native-backed classes and functions.
+	exports.Set("Database", Database::Init(env, addon));
+	exports.Set("Statement", Statement::Init(env, addon));
+	exports.Set("StatementIterator", StatementIterator::Init(env, addon));
+	exports.Set("Backup", Backup::Init(env, addon));
+	exports.Set("initialize", Napi::Function::New(env, Addon::JS_initialize, "initialize", addon));
+
+	// Store addon instance data.
+	addon->Statement = Napi::Persistent(exports.Get("Statement").As<Napi::Function>());
+	addon->StatementIterator = Napi::Persistent(exports.Get("StatementIterator").As<Napi::Function>());
+	addon->Backup = Napi::Persistent(exports.Get("Backup").As<Napi::Function>());
+
+	return exports;
+}
+
+NODE_API_MODULE(better_sqlite3, InitAll)