wowok 2.1.10 → 2.1.13

package/scripts/install-better-sqlite3.js

@@ -0,0 +1,377 @@
+#!/usr/bin/env node
+
+/**
+ * better-sqlite3 prebuilt binary installation script
+ *
+ * Hybrid approach (Option B priority, Option A fallback):
+ * 1. First check for local prebuilt binaries (Option B) - priority, no network required
+ * 2. If no matching local version, try downloading from GitHub (Option A)
+ * 3. If download fails, prompt user for manual installation
+ *
+ * This script runs in the following scenarios:
+ * - During development when running npm install
+ * - When users install the wowok package
+ * - When other packages depend on wowok
+ */
+
+const { execSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const RED = "\x1b[31m";
+const BLUE = "\x1b[34m";
+const NC = "\x1b[0m";
+
+function log(message) {
+	console.log(message);
+}
+
+function logInfo(message) {
+	console.log(`${BLUE}${message}${NC}`);
+}
+
+function logSuccess(message) {
+	console.log(`${GREEN}${message}${NC}`);
+}
+
+function logWarning(message) {
+	console.log(`${YELLOW}${message}${NC}`);
+}
+
+function logError(message) {
+	console.log(`${RED}${message}${NC}`);
+}
+
+// Detect if currently being installed as a dependency
+function getInstallContext() {
+	const cwd = process.cwd();
+	const isDependency =
+		cwd.includes("node_modules") ||
+		!fs.existsSync(path.join(cwd, "package.json"));
+	return {
+		cwd,
+		isDependency,
+		isDirectInstall: !isDependency,
+	};
+}
+
+function getPlatformInfo() {
+	const platform = process.platform;
+	const arch = process.arch;
+	const nodeAbi = process.versions.modules;
+
+	const platformMap = {
+		linux: "linux",
+		darwin: "darwin",
+		win32: "win32",
+		freebsd: "freebsd",
+	};
+
+	return {
+		platform: platformMap[platform] || platform,
+		arch,
+		nodeAbi,
+		platformKey: `${platform}-${arch}`,
+		fullKey: `node-v${nodeAbi}-${platformMap[platform] || platform}-${arch}`,
+	};
+}
+
+function findLocalPrebuilt(platformInfo, packageRoot) {
+	const prebuildsDir = path.join(packageRoot, "prebuilds");
+
+	if (fs.existsSync(prebuildsDir)) {
+		const files = fs.readdirSync(prebuildsDir);
+
+		const exactPattern = new RegExp(
+			`better-sqlite3-v[\\d.]+-${platformInfo.fullKey}\\.node$`,
+		);
+		for (const file of files) {
+			if (exactPattern.test(file)) {
+				return {
+					path: path.join(prebuildsDir, file),
+					exactMatch: true,
+					source: "package",
+				};
+			}
+		}
+
+		const platformArchPattern = new RegExp(
+			`better-sqlite3-v[\\d.]+-node-v[\\d]+-${platformInfo.platform}-${platformInfo.arch}\\.node$`,
+		);
+		for (const file of files) {
+			if (platformArchPattern.test(file)) {
+				logWarning(
+					`Found similar version: ${file} (Node ABI may not match)`,
+				);
+				return {
+					path: path.join(prebuildsDir, file),
+					exactMatch: false,
+					source: "package",
+				};
+			}
+		}
+	}
+
+	return null;
+}
+
+function copyPrebuiltToBetterSqlite3(
+	sourcePath,
+	betterSqlite3Path,
+	platformInfo,
+) {
+	const targetDir = path.join(betterSqlite3Path, "build", "Release");
+	const targetPath = path.join(targetDir, "better_sqlite3.node");
+
+	fs.mkdirSync(targetDir, { recursive: true });
+	fs.copyFileSync(sourcePath, targetPath);
+
+	const bindingDir = path.join(
+		betterSqlite3Path,
+		"lib",
+		"binding",
+		platformInfo.fullKey,
+	);
+	fs.mkdirSync(bindingDir, { recursive: true });
+	fs.copyFileSync(sourcePath, path.join(bindingDir, "better_sqlite3.node"));
+
+	return targetPath;
+}
+
+function downloadPrebuilt(platformInfo, betterSqlite3Path) {
+	const packageJsonPath = path.join(betterSqlite3Path, "package.json");
+	const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+	const version = packageJson.version;
+
+	const downloadUrl = `https://github.com/WiseLibs/better-sqlite3/releases/download/v${version}/better-sqlite3-v${version}-${platformInfo.fullKey}.tar.gz`;
+
+	const tempDir = path.join(betterSqlite3Path, ".download-temp");
+	fs.mkdirSync(tempDir, { recursive: true });
+	const tempFile = path.join(tempDir, "prebuilt.tar.gz");
+
+	try {
+		if (process.platform === "win32") {
+			execSync(
+				`powershell -Command "Invoke-WebRequest -Uri '${downloadUrl}' -OutFile '${tempFile}'"`,
+				{
+					stdio: "pipe",
+				},
+			);
+		} else {
+			execSync(`curl -L -o "${tempFile}" "${downloadUrl}"`, {
+				stdio: "pipe",
+			});
+		}
+
+		const extractDir = path.join(tempDir, "extracted");
+		fs.mkdirSync(extractDir, { recursive: true });
+		execSync(`tar -xzf "${tempFile}" -C "${extractDir}"`, {
+			stdio: "pipe",
+		});
+
+		const files = fs.readdirSync(extractDir);
+		const nodeFile = files.find((f) => f.endsWith(".node"));
+
+		if (!nodeFile) {
+			throw new Error(".node file not found");
+		}
+
+		const sourcePath = path.join(extractDir, nodeFile);
+		const targetPath = copyPrebuiltToBetterSqlite3(
+			sourcePath,
+			betterSqlite3Path,
+			platformInfo,
+		);
+
+		fs.rmSync(tempDir, { recursive: true, force: true });
+
+		return targetPath;
+	} catch (error) {
+		if (fs.existsSync(tempDir)) {
+			fs.rmSync(tempDir, { recursive: true, force: true });
+		}
+		throw error;
+	}
+}
+
+function tryPrebuildInstall(betterSqlite3Path) {
+	try {
+		execSync("npx prebuild-install --verbose", {
+			cwd: betterSqlite3Path,
+			stdio: "pipe",
+		});
+		return fs.existsSync(
+			path.join(
+				betterSqlite3Path,
+				"build",
+				"Release",
+				"better_sqlite3.node",
+			),
+		);
+	} catch (error) {
+		return false;
+	}
+}
+
+function main() {
+	const context = getInstallContext();
+	const platformInfo = getPlatformInfo();
+
+	const packageRoot = __dirname.includes("node_modules")
+		? path.resolve(__dirname, "..")
+		: process.cwd();
+
+	const isSilent = context.isDependency;
+
+	if (!isSilent) {
+		log(`${BLUE}=== better-sqlite3 Prebuilt Binary Installation ===${NC}`);
+		logInfo(`Platform: ${platformInfo.platform}-${platformInfo.arch}`);
+		logInfo(`Node.js ABI: node-v${platformInfo.nodeAbi}`);
+	}
+
+	const possiblePaths = [
+		path.join(packageRoot, "node_modules", "better-sqlite3"),
+		path.join(process.cwd(), "node_modules", "better-sqlite3"),
+		path.join(packageRoot, "..", "better-sqlite3"),
+	];
+
+	let betterSqlite3Path = null;
+	for (const p of possiblePaths) {
+		if (fs.existsSync(p)) {
+			betterSqlite3Path = p;
+			break;
+		}
+	}
+
+	if (!betterSqlite3Path) {
+		if (!isSilent) {
+			logWarning(
+				"better-sqlite3 not installed, skipping prebuilt binary installation",
+			);
+			logInfo(
+				"Tip: To use SQLite features, run: npm install better-sqlite3",
+			);
+		}
+		return;
+	}
+
+	const prebuiltPath = path.join(
+		betterSqlite3Path,
+		"build",
+		"Release",
+		"better_sqlite3.node",
+	);
+	if (fs.existsSync(prebuiltPath)) {
+		if (!isSilent) {
+			logSuccess("better-sqlite3 prebuilt binary already exists");
+		}
+		return;
+	}
+
+	if (!isSilent) {
+		logInfo("");
+		logInfo("Step 1: Looking for local prebuilt binaries...");
+	}
+
+	const localPrebuilt = findLocalPrebuilt(platformInfo, packageRoot);
+
+	if (localPrebuilt) {
+		try {
+			copyPrebuiltToBetterSqlite3(
+				localPrebuilt.path,
+				betterSqlite3Path,
+				platformInfo,
+			);
+			if (!isSilent) {
+				if (localPrebuilt.exactMatch) {
+					logSuccess(
+						"Installed successfully using local prebuilt binary!",
+					);
+				} else {
+					logWarning(
+						"Installed using similar version, but Node ABI may not match",
+					);
+					logInfo(
+						"  If issues occur, consider downloading matching version from GitHub",
+					);
+				}
+			}
+			return;
+		} catch (error) {
+			if (!isSilent) {
+				logError(`Failed to use local version: ${error.message}`);
+			}
+		}
+	} else if (!isSilent) {
+		logInfo("No local prebuilt binaries found");
+	}
+
+	if (!isSilent) {
+		logInfo("");
+		logInfo("Step 2: Trying to download prebuilt binary from GitHub...");
+	}
+
+	if (tryPrebuildInstall(betterSqlite3Path)) {
+		if (!isSilent) {
+			logSuccess("Downloaded successfully via prebuild-install!");
+		}
+		return;
+	}
+
+	try {
+		downloadPrebuilt(platformInfo, betterSqlite3Path);
+		if (!isSilent) {
+			logSuccess("Downloaded and installed successfully from GitHub!");
+		}
+		return;
+	} catch (error) {
+		if (!isSilent) {
+			logError(`Download failed: ${error.message}`);
+		}
+	}
+
+	if (!isSilent) {
+		logInfo("");
+		logWarning("========================================");
+		logWarning("better-sqlite3 prebuilt binary installation failed");
+		logWarning("========================================");
+		logInfo("");
+		logInfo("You can try the following solutions:");
+		logInfo("");
+		logInfo("1. Manually download prebuilt binary:");
+		logInfo(
+			`   Visit: https://github.com/WiseLibs/better-sqlite3/releases`,
+		);
+		logInfo(
+			`   Download: better-sqlite3-v{version}-${platformInfo.fullKey}.tar.gz`,
+		);
+		logInfo(`   Extract to: ${betterSqlite3Path}/build/Release/`);
+		logInfo("");
+		logInfo("2. Build from source (requires Python and C++ toolchain):");
+		logInfo("   npm install better-sqlite3 --build-from-source");
+		logInfo("");
+		logInfo("3. Use a compatible Node.js version:");
+		logInfo(
+			"   Check: https://github.com/WiseLibs/better-sqlite3/releases",
+		);
+		logInfo("   Find matching prebuilt binaries");
+		logInfo("");
+		logWarning("Note: better-sqlite3 will attempt to compile on first use");
+		logWarning("      Runtime errors may occur if build tools are missing");
+	} else {
+		logWarning(
+			`[wowok] better-sqlite3 prebuilt binary installation failed (${platformInfo.fullKey})`,
+		);
+		logWarning(
+			"[wowok] For SQLite features, manually install prebuilt binary or build toolchain",
+		);
+	}
+}
+
+if (require.main === module) {
+	main();
+}
+
+module.exports = { main };

package/dist/cjs/graphql/client.js

@@ -1,98 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
-var client_exports = {};
-__export(client_exports, {
-  SuiGraphQLClient: () => SuiGraphQLClient,
-  SuiGraphQLRequestError: () => SuiGraphQLRequestError
-});
-module.exports = __toCommonJS(client_exports);
-var import_graphql = require("graphql");
-var import_experimental = require("../experimental/index.js");
-var import_core = require("./core.js");
-var _url, _queries, _headers, _fetch;
-class SuiGraphQLRequestError extends Error {
-}
-class SuiGraphQLClient extends import_experimental.Experimental_BaseClient {
-  constructor({
-    url,
-    fetch: fetchFn = fetch,
-    headers = {},
-    queries = {},
-    network = "unknown",
-    mvr
-  }) {
-    super({
-      network
-    });
-    __privateAdd(this, _url);
-    __privateAdd(this, _queries);
-    __privateAdd(this, _headers);
-    __privateAdd(this, _fetch);
-    __publicField(this, "core");
-    __privateSet(this, _url, url);
-    __privateSet(this, _queries, queries);
-    __privateSet(this, _headers, headers);
-    __privateSet(this, _fetch, (...args) => fetchFn(...args));
-    this.core = new import_core.GraphQLCoreClient({
-      graphqlClient: this,
-      mvr
-    });
-  }
-  async query(options) {
-    const res = await __privateGet(this, _fetch).call(this, __privateGet(this, _url), {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        ...__privateGet(this, _headers)
-      },
-      body: JSON.stringify({
-        query: typeof options.query === "string" || options.query instanceof String ? String(options.query) : (0, import_graphql.print)(options.query),
-        variables: options.variables,
-        extensions: options.extensions,
-        operationName: options.operationName
-      }),
-      signal: options.signal
-    });
-    if (!res.ok) {
-      throw new SuiGraphQLRequestError(
-        `GraphQL request failed: ${res.statusText} (${res.status})`
-      );
-    }
-    return await res.json();
-  }
-  async execute(query, options) {
-    return this.query({
-      ...options,
-      query: __privateGet(this, _queries)[query]
-    });
-  }
-}
-_url = new WeakMap();
-_queries = new WeakMap();
-_headers = new WeakMap();
-_fetch = new WeakMap();