@paimaexample/npm-midnight-indexer 0.3.127 → 0.3.128

package/binary.js

@@ -44,6 +44,8 @@ function getBinaryUrl() {
   return `https://github.com/effectstream/binaries/releases/download/0.3.120/indexer-standalone-${platform}-${CURRENT_BINARY_VERSION}.zip`;
 }
 
+const ZIP_FILE_PATH = path.join(__dirname, "indexer-standalone.zip");
+
 /*
 @returns {Promise<void>} Downloads and saves the binary for the current platform.
 */
@@ -52,9 +54,7 @@ async function downloadAndSaveBinary() {
   try {
     console.error(`Downloading... ${url}`);
     const response = await axios.get(url, { responseType: "stream" });
-    const writer = fs.createWriteStream(
-      path.join(__dirname, "indexer-standalone.zip"),
-    );
+    const writer = fs.createWriteStream(ZIP_FILE_PATH);
 
     response.data.pipe(writer);
 
@@ -76,27 +76,65 @@ async function unzipBinary() {
   if (!fs.existsSync(dir)) {
     fs.mkdirSync(dir, { recursive: true });
   }
-  await extract(path.join(__dirname, "indexer-standalone.zip"), { dir });
+  await extract(ZIP_FILE_PATH, { dir });
   const dataDir = path.join(dir, "data");
   if (!fs.existsSync(dataDir)) {
     fs.mkdirSync(dataDir, { recursive: true });
   }
 
   const platform = getPlatform();
-  const extractedBinaryPath = path.join(
-    dir,
+  const possibleBinaryNames = [
+    `indexer-standalone-${platform}-${CURRENT_BINARY_VERSION}`,
     `indexer-standalone`,
-  );
+    `indexer-standalone-${platform}`
+  ];
+
+  let extractedBinaryPath = null;
+  for (const name of possibleBinaryNames) {
+    const p = path.join(dir, name);
+    if (fs.existsSync(p) && fs.statSync(p).isFile()) {
+      extractedBinaryPath = p;
+      break;
+    }
+  }
+
   const finalBinaryPath = path.join(dir, FINAL_BINARY_NAME);
 
   // Rename the extracted file to indexer-standalone
-  if (fs.existsSync(extractedBinaryPath)) {
-    if (fs.existsSync(finalBinaryPath)) {
-      fs.unlinkSync(finalBinaryPath);
+  if (extractedBinaryPath) {
+    if (extractedBinaryPath !== finalBinaryPath) {
+      if (fs.existsSync(finalBinaryPath)) {
+        fs.unlinkSync(finalBinaryPath);
+      }
+      fs.renameSync(extractedBinaryPath, finalBinaryPath);
     }
-    fs.renameSync(extractedBinaryPath, finalBinaryPath);
   } else {
-    throw new Error(`Extracted binary not found at: ${extractedBinaryPath}`);
+    throw new Error(`Extracted binary not found in: ${dir}. Expected one of: ${possibleBinaryNames.join(", ")}`);
+  }
+
+  // Clean up any other extracted files (e.g., readme.md)
+  const files = fs.readdirSync(dir);
+  for (const file of files) {
+    const filePath = path.join(dir, file);
+    // Explicitly protect config.yaml and other potential config files
+    const isConfigFile =
+      file === "config.yaml" ||
+      file === "config.yml" ||
+      file.endsWith(".yaml") ||
+      file.endsWith(".yml") ||
+      file.endsWith(".toml") ||
+      file.endsWith(".json");
+
+    if (
+      filePath !== finalBinaryPath &&
+      file !== "data" &&
+      !isConfigFile &&
+      fs.existsSync(filePath) &&
+      fs.statSync(filePath).isFile()
+    ) {
+      console.log(`Cleaning up extracted file: ${file}`);
+      fs.unlinkSync(filePath);
+    }
   }
 
   if (!fs.existsSync(finalBinaryPath)) {
@@ -104,7 +142,7 @@ async function unzipBinary() {
   }
 
   fs.chmodSync(finalBinaryPath, 0o755);
-  fs.unlinkSync(path.join(__dirname, "indexer-standalone.zip"));
+  fs.unlinkSync(ZIP_FILE_PATH);
 }
 
 async function binary() {

package/index.js

@@ -1,4 +1,4 @@
-const { binary } = require("./binary");
+const { binary, getPlatform } = require("./binary");
 const { runMidnightIndexer } = require("./run_midnight_indexer");
 const { checkIfDockerExists, pullDockerImage, runDockerContainer } = require(
   "./docker",
@@ -21,21 +21,9 @@ function checkIfBinaryExists() {
  * @returns {boolean} True if binary execution is supported
  */
 function isBinarySupported() {
-  const platform = os.platform();
-  const arch = os.arch();
-
-  // Check if the current platform-arch combination is supported
+  const platformString = getPlatform();
   const supportedPlatforms = require("./package.json").supportedPlatforms;
 
-  let platformString;
-  if (platform === "darwin") {
-    platformString = arch === "x64" ? "macos-amd64" : `macos-${arch}`;
-  } else {
-    platformString = arch === "x64"
-      ? `${platform}-amd64`
-      : `${platform}-${arch}`;
-  }
-
   return supportedPlatforms.includes(platformString);
 }
 

package/indexer-standalone/config.yaml

@@ -37,4 +37,4 @@ telemetry:
   metrics:
     enabled: false
     address: "0.0.0.0"
-    port: 9000
+    port: 9000

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@paimaexample/npm-midnight-indexer",
-  "version": "0.3.127",
+  "version": "0.3.128",
   "description": "Downloads and runs the Midnight Indexer. It needs a running Midnight Node",
   "main": "index.js",
   "scripts": {

package/run_midnight_indexer.js

@@ -4,6 +4,91 @@ const fs = require("fs");
 const yaml = require("js-yaml");
 
 const BINARY_NAME = "indexer-standalone";
+
+/**
+ * Resolves the configuration file path
+ * @param {Object} env - Environment variables
+ * @param {string} workingDir - The working directory where the indexer runs
+ * @returns {string} The resolved configuration file path
+ */
+function resolveConfigPath(env, workingDir) {
+  if (env.CONFIG_FILE) {
+    return path.isAbsolute(env.CONFIG_FILE)
+      ? env.CONFIG_FILE
+      : path.resolve(workingDir, env.CONFIG_FILE);
+  }
+  // Fall back to config.yaml in the current working directory
+  return path.join(workingDir, "config.yaml");
+}
+
+/**
+ * Ensures that a configuration file exists at the given path
+ * @param {string} configPath - The path to the configuration file
+ * @param {Object} env - Environment variables
+ */
+function ensureConfigExists(configPath, env) {
+  if (fs.existsSync(configPath)) {
+    return;
+  }
+
+  console.log(
+    `Config file not found. Generating default config at: ${configPath}`,
+  );
+
+  const networkId = env.LEDGER_NETWORK_ID || "Undeployed";
+  const nodeUrl = env.SUBSTRATE_NODE_WS_URL ||
+    env.APP__INFRA__NODE__URL ||
+    "ws://localhost:9944";
+  const cnnUrl = env.APP__INFRA__STORAGE__CNN_URL || "./data/indexer.sqlite";
+  const apiPort = env.APP__INFRA__API__PORT || 8088;
+
+  const defaultConfig = `
+run_migrations: true
+network_id: &network_id "${networkId}"
+
+chain_indexer_application:
+  network_id: *network_id
+  blocks_buffer: 60
+  save_zswap_state_after: 1000
+  caught_up_max_distance: 60
+  caught_up_leeway: 30
+
+wallet_indexer_application:
+  network_id: *network_id
+  active_wallets_repeat_delay: "100ms"
+  active_wallets_ttl: "30m"
+  transaction_batch_size: 10
+
+infra:
+  node:
+    url: "${nodeUrl}"
+    reconnect_max_delay: "10s"
+    reconnect_max_attempts: 30
+
+  storage:
+    cnn_url: "${cnnUrl}"
+
+  api:
+    address: "0.0.0.0"
+    port: ${apiPort}
+    request_body_limit: "1MiB"
+    max_complexity: 200
+    max_depth: 15
+    network_id: *network_id
+
+telemetry:
+  tracing:
+    enabled: false
+    service_name: "indexer"
+  metrics:
+    enabled: false
+    address: "0.0.0.0"
+    port: 9000
+`;
+
+  fs.writeFileSync(configPath, defaultConfig.trim());
+}
+
 /**
  * Resolves the SQLite database path using the midnight-indexer configuration rules
  * @param {Object} env - Environment variables
@@ -18,17 +103,7 @@ function resolveSqlitePath(env, workingDir) {
     return envCnnUrl;
   }
 
-  // Determine config file path using the configuration resolution rules
-  let configPath;
-  if (env.CONFIG_FILE) {
-    configPath = path.isAbsolute(env.CONFIG_FILE)
-      ? env.CONFIG_FILE
-      : path.resolve(workingDir, env.CONFIG_FILE);
-  } else {
-    // Fall back to config.yaml in the current working directory
-    configPath = path.join(workingDir, "config.yaml");
-  }
-
+  const configPath = resolveConfigPath(env, workingDir);
   console.log(`Looking for config file at: ${configPath}`);
 
   // Check if config file exists
@@ -65,6 +140,24 @@ function resolveSqlitePath(env, workingDir) {
   }
 }
 
+/**
+ * Resolves the SQLite database path with a fallback to the default location
+ * @param {Object} env - Environment variables
+ * @param {string} workingDir - The working directory where the indexer runs
+ * @returns {string} The resolved SQLite database path
+ */
+function resolveSqlitePathWithFallback(env, workingDir) {
+  const sqlitePath = resolveSqlitePath(env, workingDir);
+  if (sqlitePath) {
+    return sqlitePath;
+  }
+
+  // Fallback to default indexer location: data/indexer.sqlite
+  const defaultPath = path.join(workingDir, "data", "indexer.sqlite");
+  console.log(`Using default SQLite path: ${defaultPath}`);
+  return defaultPath;
+}
+
 /**
  * Handles the --clean flag by deleting the SQLite database file
  * @param {Object} env - Environment variables
@@ -73,12 +166,7 @@ function resolveSqlitePath(env, workingDir) {
 function handleCleanFlag(env, workingDir) {
   console.log("Processing --clean flag...");
 
-  const sqlitePath = resolveSqlitePath(env, workingDir);
-
-  if (!sqlitePath) {
-    console.warn("Could not resolve SQLite database path. Skipping cleanup.");
-    return;
-  }
+  const sqlitePath = resolveSqlitePathWithFallback(env, workingDir);
 
   // Handle sqlite:// URLs and extract the file path
   let filePath = sqlitePath;
@@ -118,6 +206,9 @@ function runMidnightIndexer(env = process.env, args = []) {
   );
   const workingDir = path.join(__dirname, "indexer-standalone");
 
+  const configPath = resolveConfigPath(env, workingDir);
+  ensureConfigExists(configPath, env);
+
   // Check for --clean flag and handle it
   const cleanFlagIndex = args.indexOf("--clean");
   if (cleanFlagIndex !== -1) {