@kineviz/ladybug-lite 0.15.3

package/prepared_statement.js

@@ -0,0 +1,42 @@
+"use strict";
+
+const assert = require("assert");
+
+class PreparedStatement {
+  /**
+   * Internal constructor. Use `Connection.prepare` to get a
+   * `PreparedStatement` object.
+   * @param {Connection} connection the connection object.
+   * @param {LbugNative.NodePreparedStatement} preparedStatement the native prepared statement object.
+   */
+  constructor(connection, preparedStatement) {
+    assert(
+      typeof connection === "object" &&
+        connection.constructor.name === "Connection"
+    );
+    assert(
+      typeof preparedStatement === "object" &&
+        preparedStatement.constructor.name === "NodePreparedStatement"
+    );
+    this._connection = connection;
+    this._preparedStatement = preparedStatement;
+  }
+
+  /**
+   * Check if the prepared statement is successfully prepared.
+   * @returns {Boolean} true if the prepared statement is successfully prepared.
+   */
+  isSuccess() {
+    return this._preparedStatement.isSuccess();
+  }
+
+  /**
+   * Get the error message if the prepared statement is not successfully prepared.
+   * @returns {String} the error message.
+   */
+  getErrorMessage() {
+    return this._preparedStatement.getErrorMessage();
+  }
+}
+
+module.exports = PreparedStatement;

package/query_result.js

@@ -0,0 +1,242 @@
+"use strict";
+
+const assert = require("assert");
+
+class QueryResult {
+  /**
+   * Internal constructor. Use `Connection.query` or `Connection.execute`
+   * to get a `QueryResult` object.
+   * @param {Connection} connection the connection object.
+   * @param {LbugNative.NodeQueryResult} queryResult the native query result object.
+   */
+  constructor(connection, queryResult) {
+    assert(
+      typeof connection === "object" &&
+        connection.constructor.name === "Connection"
+    );
+    assert(
+      typeof queryResult === "object" &&
+        queryResult.constructor.name === "NodeQueryResult"
+    );
+    this._connection = connection;
+    this._queryResult = queryResult;
+    this._isClosed = false;
+  }
+
+  /**
+   * Reset the iterator of the query result to the beginning.
+   * This function is useful if the query result is iterated multiple times.
+   */
+  resetIterator() {
+    this._checkClosed();
+    this._queryResult.resetIterator();
+  }
+
+  /**
+   * Check if the query result has more rows.
+   * @returns {Boolean} true if the query result has more rows.
+   */
+  hasNext() {
+    this._checkClosed();
+    return this._queryResult.hasNext();
+  }
+
+  /**
+   * Get the number of rows of the query result.
+   * @returns {Number} the number of rows of the query result.
+   */
+  getNumTuples() {
+    this._checkClosed();
+    return this._queryResult.getNumTuples();
+  }
+
+  /**
+   * Get the next row of the query result.
+   * @returns {Promise<Object>} a promise that resolves to the next row of the query result. The promise is rejected if there is an error.
+   */
+  getNext() {
+    this._checkClosed();
+    return new Promise((resolve, reject) => {
+      this._queryResult.getNextAsync((err, result) => {
+        if (err) {
+          return reject(err);
+        }
+        return resolve(result);
+      });
+    });
+  }
+
+  /**
+   * Get the next row of the query result synchronously.
+   * @returns {Object} the next row of the query result.
+   */
+  getNextSync() {
+    this._checkClosed();
+    return this._queryResult.getNextSync();
+  }
+
+  /**
+   * Iterate through the query result with callback functions.
+   * @param {Function} resultCallback the callback function that is called for each row of the query result.
+   * @param {Function} doneCallback the callback function that is called when the iteration is done.
+   * @param {Function} errorCallback the callback function that is called when there is an error.
+   */
+  each(resultCallback, doneCallback, errorCallback) {
+    this._checkClosed();
+    if (!this.hasNext()) {
+      return doneCallback();
+    }
+    this.getNext()
+      .then((row) => {
+        resultCallback(row);
+        this.each(resultCallback, doneCallback, errorCallback);
+      })
+      .catch((err) => {
+        errorCallback(err);
+      });
+  }
+
+  /**
+   * Get all rows of the query result.
+   * @returns {Promise<Array<Object>>} a promise that resolves to all rows of the query result. The promise is rejected if there is an error.
+   */
+  async getAll() {
+    this._checkClosed();
+    this._queryResult.resetIterator();
+    const result = [];
+    while (this.hasNext()) {
+      result.push(await this.getNext());
+    }
+    return result;
+  }
+
+  /**
+   * Get all rows of the query result synchronously. Note that this function can block the main thread if the number of rows is large, so use it with caution.
+   * @returns {Array<Object>} all rows of the query result.
+   */
+  getAllSync() {
+    this._checkClosed();
+    this._queryResult.resetIterator();
+    const result = [];
+    while (this.hasNext()) {
+      result.push(this.getNextSync());
+    }
+    return result;
+  }
+
+  /**
+   * Get all rows of the query result with callback functions.
+   * @param {Function} resultCallback the callback function that is called with all rows of the query result.
+   * @param {Function} errorCallback the callback function that is called when there is an error.
+   */
+  all(resultCallback, errorCallback) {
+    this._checkClosed();
+    this.getAll()
+      .then((result) => {
+        resultCallback(result);
+      })
+      .catch((err) => {
+        errorCallback(err);
+      });
+  }
+
+  /**
+   * Get the data types of the columns of the query result.
+   * @returns {Promise<Array<String>>} a promise that resolves to the data types of the columns of the query result. The promise is rejected if there is an error.
+   */
+  getColumnDataTypes() {
+    this._checkClosed();
+    return new Promise((resolve, reject) => {
+      this._queryResult.getColumnDataTypesAsync((err, result) => {
+        if (err) {
+          return reject(err);
+        }
+        return resolve(result);
+      });
+    });
+  }
+
+  /**
+   * Get the data types of the columns of the query result synchronously.
+   * @returns {Array<String>} the data types of the columns of the query result.
+   */
+  getColumnDataTypesSync() {
+    this._checkClosed();
+    return this._queryResult.getColumnDataTypesSync();
+  }
+
+  /**
+   * Get the names of the columns of the query result.
+   * @returns {Promise<Array<String>>} a promise that resolves to the names of the columns of the query result. The promise is rejected if there is an error.
+   */
+  getColumnNames() {
+    this._checkClosed();
+    return new Promise((resolve, reject) => {
+      this._queryResult.getColumnNamesAsync((err, result) => {
+        if (err) {
+          return reject(err);
+        }
+        return resolve(result);
+      });
+    });
+  }
+
+  /**
+   * Get the names of the columns of the query result synchronously.
+   * @returns {Array<String>} the names of the columns of the query result.
+   */
+  getColumnNamesSync() {
+    this._checkClosed();
+    return this._queryResult.getColumnNamesSync();
+  }
+
+  /**
+   * Get the query summary (compiling and execution time) of the query result.
+   * @returns {Promise<Object>} a promise that resolves to the query summary of the query result. The promise is rejected if there is an error.
+   */
+  getQuerySummary() {
+    this._checkClosed();
+    return new Promise((resolve, reject) => {
+      this._queryResult.getQuerySummaryAsync((err, result) => {
+        if (err) {
+          return reject(err);
+        }
+        return resolve(result);
+      });
+    });
+  }
+
+  /**
+   * Get the query summary (compiling and execution time) of the query result synchronously.
+   * @returns {Object} the query summary of the query result.
+   */
+  getQuerySummarySync() {
+    this._checkClosed();
+    return this._queryResult.getQuerySummarySync();
+  }
+
+  /**
+   * Close the query result.
+   */
+  close() {
+    if (this._isClosed) {
+      return;
+    }
+    this._queryResult.close();
+    delete this._queryResult;
+    this._connection = null;
+    this._isClosed = true;
+  }
+
+  /**
+   * Internal function to check if the query result is closed.
+   * @throws {Error} if the query result is closed.
+   */
+  _checkClosed() {
+    if (this._isClosed) {
+      throw new Error("Query result is closed.");
+    }
+  }
+}
+
+module.exports = QueryResult;

package/util/build.js

@@ -0,0 +1,248 @@
+
+
+const fs = require("fs");
+const path = require("path");
+
+
+/**
+ * Install packages
+ */
+
+const installPackage = (packageName, group = 'dev') => {
+
+  console.log(
+    `Install package ${packageName}...`
+  );
+  const childProcess = require("child_process");
+  childProcess.execSync(`npm install ${packageName} --save-dev`, {
+    cwd: rootDir,
+    stdio: "inherit",
+  });
+
+}
+
+
+/**
+ * Copies files from the 'node_modules/@ladybugdb/core' directory to the current directory.
+ * Excludes specific directories ('lbug-source', 'node_modules') and specific files ('lbugjs.node', 'package.json').
+ */
+
+const copyDir = (src, dest, excludeEntries = []) => {
+  if (!fs.existsSync(dest)) {
+    fs.mkdirSync(dest, { recursive: true });
+  }
+
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      if (!excludeEntries.includes(entry.name)) {
+        copyDir(srcPath, destPath);
+      }
+    } else if (!excludeEntries.includes(entry.name)) {
+      fs.copyFileSync(srcPath, destPath);
+      console.log(`Copied: ${srcPath} -> ${destPath}`);
+    }
+  }
+};
+
+/**
+ * Deletes all files and directories in the current directory
+ * except for 'copy.js', 'package.json', and the 'node_modules' directory.
+ */
+const deleteFiles = (directory, excludeEntries = []) => {
+  const entries = fs.readdirSync(directory, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(directory, entry.name);
+
+    // Skip if the entry is in the exclusion list
+    if (excludeEntries.includes(entry.name)) {
+      continue;
+    }
+
+    if (entry.isDirectory()) {
+      // Recursively delete directory contents then the directory itself
+      fs.rmSync(fullPath, { recursive: true, force: true });
+      console.log(`Deleted directory: ${fullPath}`);
+    } else {
+      // Delete file
+      fs.unlinkSync(fullPath);
+      console.log(`Deleted file: ${fullPath}`);
+    }
+  }
+};
+
+const npmPublish = (package) => {
+  console.log(
+    `Publishing package ${package.name}(${package.version})... to npm`
+  );
+  const npmrcPath = path.join(rootDir, ".npmrc");
+  fs.writeFileSync(
+    npmrcPath,
+    `//registry.npmjs.org/:_authToken=${process.env.NPM_TOKEN}\n`,
+    { encoding: "utf-8" }
+  );
+
+  const childProcess = require("child_process");
+  try {
+    childProcess.execSync("npm publish --access public --registry https://registry.npmjs.org", {
+      cwd: rootDir,
+      stdio: "inherit",
+    });
+  } catch (err) {
+    console.error("npm publish failed:", err);
+  }
+};
+
+/**
+ * Fetches platform-specific prebuilt binaries from the scoped @ladybugdb/core-*
+ * packages and copies each one's lbugjs.node into ./prebuilt/, remapping x64
+ * filenames to amd64 so the runtime loader can find them.
+ */
+const copyPrebuiltBinaries = () => {
+  const corePackageJsonPath = path.join(srcDir, "package.json");
+  if (!fs.existsSync(corePackageJsonPath)) {
+    console.error("@ladybugdb/core package.json not found, skipping prebuilt fetch");
+    return;
+  }
+  const lbugVersion = JSON.parse(fs.readFileSync(corePackageJsonPath, "utf8")).version;
+
+  const platformPackages = [
+    "core-darwin-arm64",
+    "core-linux-arm64",
+    "core-linux-x64",
+    "core-win32-x64",
+  ];
+
+  const installArgs = platformPackages
+    .map((pkg) => `@ladybugdb/${pkg}@${lbugVersion}`)
+    .join(" ");
+
+  console.log(`Installing platform-specific prebuilt packages: ${installArgs}`);
+  const childProcess = require("child_process");
+  childProcess.execSync(`npm install --force --no-save ${installArgs}`, {
+    cwd: rootDir,
+    stdio: "inherit",
+  });
+
+  const prebuiltDir = path.join(rootDir, "prebuilt");
+  if (!fs.existsSync(prebuiltDir)) {
+    fs.mkdirSync(prebuiltDir, { recursive: true });
+  }
+
+  for (const pkg of platformPackages) {
+    const suffix = pkg.replace(/^core-/, "").replace(/-x64$/, "-amd64");
+    const srcBin = path.join(rootDir, "node_modules", "@ladybugdb", pkg, "lbugjs.node");
+    const destBin = path.join(prebuiltDir, `lbugjs-${suffix}.node`);
+    if (fs.existsSync(srcBin)) {
+      fs.copyFileSync(srcBin, destBin);
+      console.log(`Copied: ${srcBin} -> ${destBin}`);
+    } else {
+      console.warn(`Source binary not found: ${srcBin}`);
+    }
+  }
+};
+
+const asyncVersion = () => {
+  // Copy version from node_modules/@ladybugdb/core/package.json to ./package.json
+  const lbugPackageJsonPath = path.join(srcDir, "package.json");
+  const projectPackageJsonPath = path.join(rootDir, "package.json");
+
+  if (
+    !fs.existsSync(lbugPackageJsonPath) ||
+    !fs.existsSync(projectPackageJsonPath)
+  ) {
+    console.error("the package.json file not found");
+  }
+
+  let lbugPackageJson = {};
+  let projectPackageJson = {};
+  try {
+    // Read both package.json files
+    lbugPackageJson = JSON.parse(fs.readFileSync(lbugPackageJsonPath, "utf8"));
+    projectPackageJson = JSON.parse(
+      fs.readFileSync(projectPackageJsonPath, "utf8")
+    );
+  } catch (error) {
+    console.error("Can not parse the package.json version:", error);
+  }
+
+  if (projectPackageJson.version != lbugPackageJson.version) {
+    projectPackageJson.version = lbugPackageJson.version;
+    projectPackageJson.devDependencies["@ladybugdb/core"] = lbugPackageJson.version;
+    // Write the updated package.json back
+    fs.writeFileSync(
+      projectPackageJsonPath,
+      JSON.stringify(projectPackageJson, null, 2)
+    );
+    console.log(`Updated package.json version to ${lbugPackageJson.version}`);
+    npmPublish(projectPackageJson);
+  } else {
+    console.log(
+      `Package.json version is already up to date: ${lbugPackageJson.version}`
+    );
+  }
+};
+
+const rootDir = path.join(__dirname, "..");
+
+// already install @ladybugdb/core with docker or action
+// installPackage("@ladybugdb/core");
+
+// Delete files before copying new ones
+deleteFiles(rootDir, [
+  "package.json",
+  "util",
+  "node_modules",
+  "README.md",
+  "test",
+  ".git",
+  ".vscode",
+  ".gitignore",
+  ".github",
+  ".dockerignore",
+  "Dockerfile",
+  ".npmignore",
+  "docs",
+  "prebuilt"
+]);
+
+const srcDir = path.join(rootDir, "node_modules", "@ladybugdb", "core");
+const destDir = path.join(rootDir);
+
+if (fs.existsSync(srcDir)) {
+  copyDir(srcDir, destDir, [
+    "lbug-source",
+    "node_modules",
+    "lbugjs.node",
+    "package.json",
+    "install.js",
+    "README.md",
+    "test",
+    ".gitignore",
+    ".github",
+    ".dockerignore",
+    ".npmignore",
+    "Dockerfile",
+    "prebuilt",
+  ]);
+  console.log("Copying completed!");
+} else {
+  console.error("Source directory not found:", srcDir);
+}
+
+// Fetch platform-specific prebuilt binaries only on linux-x64 so a single CI
+// runner produces them (matches the former `if: matrix.arch == 'amd64'` gate).
+if (process.platform === "win32" || (process.platform === "linux" && process.arch === "x64")) {
+  copyPrebuiltBinaries();
+} else {
+  console.log(
+    `Skipping platform-specific prebuilt fetch on ${process.platform}-${process.arch}`
+  );
+}
+
+asyncVersion();

package/util/build.md

@@ -0,0 +1,90 @@
+# 1. 在宿主机（非容器内）安装 QEMU
+# sudo apt-get install qemu-user-static  # Debian/Ubuntu
+
+# re-install @ladybugdb/core for clean all build info
+yarn remove @ladybugdb/core 
+yarn add @ladybugdb/core --no-cache
+
+
+# 2. run qemu-aarch64-alpine and qemu-amd64-alpine
+
+
+docker rm -f qemu-aarch64-alpine \
+&& \
+docker run -it \
+--name qemu-aarch64-alpine \
+-v ./:/app \
+--platform linux/arm64 \
+node:18-alpine
+
+
+ 
+docker rm -f qemu-amd64-alpine \
+&& \
+docker run -it \
+--platform linux/amd64 \
+-v ./:/app \
+--name qemu-amd64-alpine \
+node:18-alpine
+
+
+
+# 3. go to ladybug source
+
+cd /app/node_modules/@ladybugdb/core/lbug-source/tools/nodejs_api
+
+
+# 4. run ***yarn***
+
+yarn install --no-cache
+ 
+
+# 5. install  dependencies  (alpine)
+apk add --no-cache -X https://mirrors.aliyun.com/alpine/v3.21/main  \
+    g++ \
+    gcompat \
+    libc6-compat \
+    build-base \
+    python3 \
+    libressl-dev \
+    make \
+    cmake \
+    zlib-dev \
+    musl-dev 
+
+# 5.1 install  dependencies  (ubuntu)
+
+sudo apt update
+sudo apt install -y \
+    g++ \
+    make \
+    cmake \
+    python3 \
+    libssl-dev \
+    zlib1g-dev \
+    musl-tools \
+    musl-dev \
+    gcc-aarch64-linux-gnu \
+    g++-aarch64-linux-gnu \
+    build-essential \
+    pkg-config \
+    wget \
+    curl
+
+
+
+
+# 6.  yarn build
+
+```sh
+# 替换 build.js 文件中的 "THREADS =" 为 "THREADS = 2;//"
+sed -i 's/THREADS =/THREADS = 2;\/\//' build.js
+```
+
+```
+yarn build
+```
+ 
+
+# 7.  copy the lbugjs.node to lbugjs-alpine-arm64.node
+cp -f /app/node_modules/@ladybugdb/core/lbug-source/tools/nodejs_api/build/lbugjs.node /app/node_modules/@ladybugdb/core/prebuilt/lbugjs-alpine-arm64.node

package/util/buildLadybugExtensions.sh

@@ -0,0 +1,79 @@
+#!/bin/bash
+
+# Script that only compiles Ladybug extensions, supports LBUG_DIR environment variable
+# apk add --no-cache openssl openssl-dev
+APP_ROOT_DIR=$(cd $(dirname "${BASH_SOURCE[0]}")/..; pwd)
+LBUG_SOURCE_DIR="$APP_ROOT_DIR/node_modules/@ladybugdb/core/lbug-source"
+EXTENSION_DIR="${LBUG_SOURCE_DIR}/extension"
+
+
+SYSTEM="$(uname -o)"
+if [ "$SYSTEM" = "Msys" ]; then
+    export MSYS2_ARG_CONV_EXCL="*"
+    echo "Msys"
+    APP_ROOT_DIR="$(cygpath -w $APP_ROOT_DIR)"
+    LBUG_SOURCE_DIR="$(cygpath -w $LBUG_SOURCE_DIR)"
+    EXTENSION_DIR="$(cygpath -w $EXTENSION_DIR)"
+fi
+
+#EXTENSION_LIST="$(find "${EXTENSION_DIR}" -mindepth 1 -maxdepth 1 -type d -exec basename {} \; | grep -v '^duckdb$' | sort | tr '\n' ';' | sed 's/;$//')"
+EXTENSION_LIST="httpfs;json;fts;vector;neo4j;algo"
+echo "Automatically detected extension list: ${EXTENSION_LIST}"
+
+if [ ! -f "${LBUG_SOURCE_DIR}/CMakeLists.txt" ] || [ ! -d "${LBUG_SOURCE_DIR}/extension" ]; then
+    echo "Error: Please run this script in the root directory of the ladybug repository, or set the LBUG_DIR environment variable to point to the ladybug source directory"
+    echo "Current LBUG_SOURCE_DIR: ${LBUG_SOURCE_DIR}"
+    exit 1
+fi
+
+BUILD_DIR="${LBUG_SOURCE_DIR}/build_extensions"
+if [ ! -d "$BUILD_DIR" ]; then
+    mkdir "$BUILD_DIR"
+fi
+
+cd "$BUILD_DIR" || exit 1
+
+# Check if already compiled, if so delete it
+if [ -d "extension" ]; then
+    echo "Detected existing extension directory, deleting..."
+    rm -rf extension
+fi
+
+echo "Configuring CMake to build only extensions..."
+echo "Source directory: ${LBUG_SOURCE_DIR}"
+cmake "${LBUG_SOURCE_DIR}" \
+    -DCMAKE_BUILD_TYPE=Release \
+    -DBUILD_EXTENSIONS="${EXTENSION_LIST}" \
+    -DOPENSSL_CRYPTO_LIBRARY=/usr/lib/libcrypto.so \
+    -DOPENSSL_SSL_LIBRARY=/usr/lib/libssl.so \
+    -DOPENSSL_USE_STATIC_LIBS=OFF \
+    -DBUILD_LBUG=FALSE
+
+CORES=$(nproc --all)
+echo "Using $CORES cores for compilation..."
+
+# Use all target for compilation (more generic)
+cmake --build . -- -j"$CORES"
+
+echo "All extensions compiled successfully!"
+
+#check cpu architecture
+ARCH=$(uname -m)
+if [ "$ARCH" = "x86_64" ]; then
+    echo "Detected x86_64 architecture"
+    ARCH="amd64"
+elif [ "$ARCH" = "aarch64" ]; then
+    echo "Detected aarch64 architecture"
+    ARCH="arm64"
+else
+    echo "Unsupported architecture: $ARCH"
+    exit 1
+fi
+
+EXTENSION_DIST_DIR="${LBUG_SOURCE_DIR}/extension/alpine-${ARCH}"
+mkdir -p $EXTENSION_DIST_DIR
+find "${LBUG_SOURCE_DIR}/extension" -type f \( -path "*/build/*.lbug_extension" -o -path "*/build/*.kuzu_extension" \) -exec cp {} $EXTENSION_DIST_DIR \;
+
+# find "/app/node_modules/@ladybugdb/core/lbug-source/extension" -type f -path "*/build/*.lbug_extension" -exec cp {} /app/extensions/alpine-amd64 \;
+
+echo "All extensions have been copied to the $EXTENSION_DIST_DIR directory"