snowpipe-streaming 1.4.0

package/src/index.js

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2025 Snowflake Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+"use strict";
+
+const { loadNativeAddon } = require("./loader.js");
+const { StreamingIngestError } = require("./errors.js");
+const { ChannelStatus } = require("./channel_status.js");
+const { StreamingIngestClient, createClient: _createClient } = require("./client.js");
+const { StreamingIngestChannel } = require("./channel.js");
+
+// Load native addon and bootstrap the Rust runtime
+const native = loadNativeAddon();
+native.bootstrap(process.versions.node);
+
+// Build error codes from Rust — single source of truth.
+// Converts camelCase variant names to SCREAMING_SNAKE_CASE keys.
+// e.g., "ConfigError" -> { CONFIG_ERROR: "ConfigError" }
+function toScreamingSnake(s) {
+  return s.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toUpperCase();
+}
+
+const errorCodes = native.getErrorCodes();
+const StreamingIngestErrorCode = Object.freeze(
+  Object.fromEntries(errorCodes.map((code) => [toScreamingSnake(code), code])),
+);
+
+module.exports = {
+  createClient: (options) => _createClient(native, options),
+  StreamingIngestClient,
+  StreamingIngestChannel,
+  StreamingIngestError,
+  StreamingIngestErrorCode,
+  ChannelStatus,
+  // E2E testing only - available when compiled with e2e_test feature
+  registerMockRoute: native.registerMockRoute,
+};

package/src/loader.js

@@ -0,0 +1,167 @@
+/*
+ * Copyright 2025 Snowflake Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+"use strict";
+
+const path = require("node:path");
+const fs = require("node:fs");
+
+const LOG_PREFIX = "[snowpipe-streaming]";
+
+/**
+ * Platform package name mappings.
+ * Maps (os, arch, libc) to the npm package suffix.
+ */
+const PLATFORM_PACKAGES = {
+  "darwin-arm64": "darwin-arm64",
+  "linux-x64-glibc": "linux-x64-gnu",
+  "linux-x64-musl": "linux-x64-musl",
+  "linux-arm64-glibc": "linux-arm64-gnu",
+  "linux-arm64-musl": "linux-arm64-musl",
+  "win32-x64": "win32-x64-msvc",
+};
+
+/**
+ * Detect whether the Linux system uses musl or glibc.
+ * Uses multiple detection strategies for reliability.
+ * @returns {"glibc" | "musl"}
+ */
+function detectLibc() {
+  // Strategy 1: Check if /lib/ld-musl-* exists (Alpine, musl-based distros)
+  try {
+    const libDir = fs.readdirSync("/lib");
+    if (libDir.some((f) => f.startsWith("ld-musl-"))) {
+      console.log(`${LOG_PREFIX} Detected musl libc (found /lib/ld-musl-*)`);
+      return "musl";
+    }
+  } catch {
+    // /lib doesn't exist or not readable, continue to next strategy
+  }
+
+  // Strategy 2: Check ldd version output
+  try {
+    const { execSync } = require("node:child_process");
+    const lddOutput = execSync("ldd --version 2>&1", { encoding: "utf8" });
+    if (lddOutput.includes("musl")) {
+      console.log(`${LOG_PREFIX} Detected musl libc (ldd --version)`);
+      return "musl";
+    }
+  } catch {
+    // ldd not available or failed, continue
+  }
+
+  // Strategy 3: Check process.report (Node.js 12+)
+  if (process.report && typeof process.report.getReport === "function") {
+    const report = process.report.getReport();
+    if (report?.header?.glibcVersionRuntime) {
+      console.log(
+        `${LOG_PREFIX} Detected glibc ${report.header.glibcVersionRuntime} (process.report)`,
+      );
+      return "glibc";
+    }
+  }
+
+  // Default to glibc (most common)
+  console.log(`${LOG_PREFIX} Defaulting to glibc (no musl indicators found)`);
+  return "glibc";
+}
+
+/**
+ * Get the platform key for the current system.
+ * @returns {string} Platform key like "linux-x64-glibc" or "darwin-arm64"
+ */
+function getPlatformKey() {
+  const platform = process.platform;
+  const arch = process.arch;
+
+  if (platform === "linux") {
+    const libc = detectLibc();
+    const key = `${platform}-${arch}-${libc}`;
+    console.log(`${LOG_PREFIX} Platform: ${key} (os=${platform}, arch=${arch}, libc=${libc})`);
+    return key;
+  }
+
+  const key = `${platform}-${arch}`;
+  console.log(`${LOG_PREFIX} Platform: ${key} (os=${platform}, arch=${arch})`);
+  return key;
+}
+
+/**
+ * Load the native addon for the current platform.
+ * Supports three loading modes:
+ * 1. ADDON_PATH env var (Bazel development)
+ * 2. Platform-specific npm package (production via npm install)
+ * 3. Local .node file fallback (legacy/testing)
+ *
+ * @returns {object} The loaded native addon
+ */
+function loadNativeAddon() {
+  // Mode 1: Bazel development - ADDON_PATH points directly to the .node file
+  if (process.env.ADDON_PATH) {
+    const addonPath = path.resolve(process.env.ADDON_PATH);
+    console.log(`${LOG_PREFIX} Loading native addon from ADDON_PATH: ${addonPath}`);
+    const addon = require(addonPath);
+    console.log(`${LOG_PREFIX} Native addon loaded successfully from ADDON_PATH`);
+    return addon;
+  }
+
+  // Mode 2: Production - load from platform-specific npm package
+  const platformKey = getPlatformKey();
+  const packageSuffix = PLATFORM_PACKAGES[platformKey];
+
+  if (packageSuffix) {
+    const packageName = `snowpipe-streaming-${packageSuffix}`;
+    console.log(`${LOG_PREFIX} Attempting to load platform package: ${packageName}`);
+    try {
+      const addon = require(packageName);
+      console.log(`${LOG_PREFIX} Native addon loaded successfully from ${packageName}`);
+      return addon;
+    } catch (err) {
+      // Package not installed - fall through to fallback
+      if (err.code !== "MODULE_NOT_FOUND") {
+        console.error(`${LOG_PREFIX} Failed to load ${packageName}: ${err.message}`);
+        throw err;
+      }
+      console.log(`${LOG_PREFIX} Platform package ${packageName} not found, trying local fallback`);
+    }
+  } else {
+    console.log(
+      `${LOG_PREFIX} No platform package mapping for ${platformKey}, trying local fallback`,
+    );
+  }
+
+  // Mode 3: Fallback - local .node file (for testing or manual installation)
+  const localAddon = path.resolve(__dirname, "..", "snowpipe_streaming.node");
+  console.log(`${LOG_PREFIX} Checking for local addon: ${localAddon}`);
+  if (fs.existsSync(localAddon)) {
+    console.log(`${LOG_PREFIX} Loading native addon from local file: ${localAddon}`);
+    const addon = require(localAddon);
+    console.log(`${LOG_PREFIX} Native addon loaded successfully from local file`);
+    return addon;
+  }
+
+  // No addon found - provide helpful error message
+  const supported = Object.keys(PLATFORM_PACKAGES).join(", ");
+  const errorMsg =
+    `Unsupported platform: ${platformKey}. ` +
+    `Supported platforms: ${supported}. ` +
+    `If you're on a supported platform, ensure the package installed correctly.`;
+  console.error(`${LOG_PREFIX} ${errorMsg}`);
+  throw new Error(errorMsg);
+}
+
+module.exports = { loadNativeAddon };