@thangnm.nip/irouter 0.0.13 → 0.0.14

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

@@ -1,189 +0,0 @@
-'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) || !(columns = [...columns]).every(x => typeof x === 'string')) {
-		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) || !(parameters = [...parameters]).every(x => typeof x === 'string')) {
-			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;

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

@@ -1,78 +0,0 @@
-'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),
-			rollback: db.prepare('ROLLBACK', self, false),
-			savepoint: db.prepare('SAVEPOINT `\t_bs3.\t`', self, false),
-			release: db.prepare('RELEASE `\t_bs3.\t`', self, false),
-			rollbackTo: db.prepare('ROLLBACK TO `\t_bs3.\t`', self, false),
-		};
-		controllers.set(db, controller = {
-			default: Object.assign({ begin: db.prepare('BEGIN', self, false) }, shared),
-			deferred: Object.assign({ begin: db.prepare('BEGIN DEFERRED', self, false) }, shared),
-			immediate: Object.assign({ begin: db.prepare('BEGIN IMMEDIATE', self, false) }, shared),
-			exclusive: Object.assign({ begin: db.prepare('BEGIN EXCLUSIVE', self, 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/app/node_modules/better-sqlite3/lib/methods/wrappers.js

@@ -1,54 +0,0 @@
-'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/app/node_modules/better-sqlite3/lib/sqlite-error.js

@@ -1,20 +0,0 @@
-'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/app/node_modules/better-sqlite3/lib/util.js

@@ -1,12 +0,0 @@
-'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/app/node_modules/better-sqlite3/package.json

@@ -1,59 +0,0 @@
-{
-  "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/hooks/postinstall.js

@@ -1,125 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Postinstall hook for 9router CLI
- *
- * The standalone Next.js build ships a pre-compiled better-sqlite3 binary
- * (built on the publisher's machine). When installed on a different platform,
- * the binary is invalid. This hook detects the mismatch and forces a
- * fresh install of better-sqlite3 from npm registry.
- */
-
-const { execSync } = require("child_process");
-const fs = require("fs");
-const path = require("path");
-
-const appDir = path.join(__dirname, "..", "app");
-const nodeModulesDir = path.join(appDir, "node_modules");
-const betterSqlitePath = path.join(nodeModulesDir, "better-sqlite3");
-
-console.log("[postinstall] Checking better-sqlite3 native binary...");
-console.log("[postinstall] Platform:", process.platform, process.arch);
-console.log("[postinstall] App dir:", appDir);
-
-// Check if better-sqlite3 exists and binary is valid
-if (fs.existsSync(betterSqlitePath) && isValidBinary()) {
-  console.log("[postinstall] better-sqlite3 binary is valid ✓");
-  process.exit(0);
-}
-
-// Need to install/reinstall
-console.log("[postinstall] Binary invalid or missing, reinstalling better-sqlite3...");
-
-// Get version from existing package or fallback
-let version = "^12.6.2";
-try {
-  const pkg = JSON.parse(
-    fs.readFileSync(path.join(betterSqlitePath, "package.json"), "utf-8")
-  );
-  version = pkg.version;
-} catch {}
-
-// Strategy: remove old, install fresh in app/node_modules
-try {
-  // 1. Remove broken copy
-  if (fs.existsSync(betterSqlitePath)) {
-    console.log("[postinstall] Removing old better-sqlite3...");
-    fs.rmSync(betterSqlitePath, { recursive: true, force: true });
-  }
-
-  // 2. Install fresh - use --prefix to ensure it installs in app dir
-  console.log(`[postinstall] Installing better-sqlite3@${version}...`);
-  
-  // Ensure node_modules exists
-  if (!fs.existsSync(nodeModulesDir)) {
-    fs.mkdirSync(nodeModulesDir, { recursive: true });
-  }
-
-  // Use --prefix to target app directory explicitly
-  execSync(
-    `npm install better-sqlite3@${version} --prefix "${appDir}" --no-save --no-package-lock`,
-    {
-      stdio: "inherit",
-      timeout: 180000,
-      env: { ...process.env, npm_config_loglevel: "warn" },
-    }
-  );
-
-  // 3. Verify
-  if (isValidBinary()) {
-    console.log("[postinstall] better-sqlite3 installed successfully ✓");
-  } else {
-    console.warn("[postinstall] ⚠ Binary still invalid after install");
-    printBuildToolsHelp();
-  }
-} catch (error) {
-  console.warn("[postinstall] ⚠ Failed to install better-sqlite3:", error.message);
-  printBuildToolsHelp();
-  // Don't fail the entire install
-  process.exit(0);
-}
-
-// ─── Helpers ────────────────────────────────────────────────────────────────
-
-function isValidBinary() {
-  const binaryPath = path.join(
-    betterSqlitePath, "build", "Release", "better_sqlite3.node"
-  );
-
-  if (!fs.existsSync(binaryPath)) {
-    console.log("[postinstall] Binary not found at:", binaryPath);
-    return false;
-  }
-
-  try {
-    const fd = fs.openSync(binaryPath, "r");
-    const buffer = Buffer.alloc(4);
-    fs.readSync(fd, buffer, 0, 4, 0);
-    fs.closeSync(fd);
-
-    const magic = buffer.toString("hex");
-    const platform = process.platform;
-
-    const valid =
-      (platform === "linux" && magic.startsWith("7f454c46")) ||
-      (platform === "darwin" && (magic.startsWith("cffaedfe") || magic.startsWith("cefaedfe"))) ||
-      (platform === "win32" && magic.startsWith("4d5a"));
-
-    if (!valid) {
-      console.log(`[postinstall] Binary format mismatch: got ${magic}, platform=${platform}`);
-    }
-    return valid;
-  } catch (err) {
-    console.log("[postinstall] Cannot read binary:", err.message);
-    return false;
-  }
-}
-
-function printBuildToolsHelp() {
-  console.warn("[postinstall] Ensure build tools are installed:");
-  console.warn("[postinstall]   Ubuntu/Debian: apt install -y python3 make gcc g++");
-  console.warn("[postinstall]   CentOS/RHEL:   yum install -y python3 make gcc gcc-c++");
-  console.warn("[postinstall]   macOS:         xcode-select --install");
-  console.warn("[postinstall] Then run manually:");
-  console.warn(`[postinstall]   cd ${appDir} && rm -rf node_modules/better-sqlite3 && npm install better-sqlite3@${version || "latest"} --no-save`);
-}