@mimersql/node-mimer 1.0.0 → 1.0.2

package/README.md

@@ -4,8 +4,8 @@ Node.js driver for Mimer SQL using the Mimer SQL C API.
 
 ## Features
 
-- Direct bindings to the Mimer SQL C API via [Koffi](https://koffi.dev/) FFI - no ODBC required
-- Pure JavaScript - no C++ compiler needed at install time
+- Native C++ bindings to the Mimer SQL C API via Node-API — no ODBC required
+- Prebuilt binaries for supported platforms — no compiler needed at install time
 - Promise-based API
 - Parameterized queries with `?` placeholders (SQL injection safe)
 - Prepared statements for repeated execution
@@ -21,16 +21,16 @@ Node.js driver for Mimer SQL using the Mimer SQL C API.
 - Node.js 18.0 or later
 - Mimer SQL 11.0 or later installed (the `libmimerapi` shared library must be available)
 
-No C++ compiler is required. The package uses Koffi FFI to call the Mimer SQL C API
-directly from JavaScript.
-
 ## Installation
 
 ```bash
 npm install @mimersql/node-mimer
 ```
 
-That's it. No native compilation, no prebuilt binaries to download.
+Prebuilt binaries are included for supported platforms (linux-x64, linux-arm64,
+darwin-x64, darwin-arm64, win32-x64). On other platforms, the install script
+will compile from source using `node-gyp` (requires a C++ compiler and Mimer SQL
+development headers).
 
 ### Verifying Mimer SQL is found
 
@@ -363,24 +363,6 @@ try {
 | BOOLEAN | Boolean |
 | NULL | null |
 
-## Backend Selection
-
-By default, `node-mimer` uses the Koffi FFI backend (pure JavaScript).
-
-If the optional [`node-mimer-native`](https://github.com/user/node-mimer-native)
-package is installed, it will be used instead. This can be useful as a fallback
-if Koffi is ever unavailable for a given platform.
-
-You can force a specific backend with the `NODE_MIMER_BACKEND` environment variable:
-
-```bash
-# Force Koffi FFI (default)
-NODE_MIMER_BACKEND=koffi npm test
-
-# Force native C++ addon (requires node-mimer-native)
-NODE_MIMER_BACKEND=native npm test
-```
-
 ## API Reference
 
 ### MimerClient
@@ -573,16 +555,10 @@ npm test
 
 # Run a single test file
 node --test test/unicode.test.js
-
-# Test with a specific backend
-NODE_MIMER_BACKEND=koffi npm test
-NODE_MIMER_BACKEND=native npm test   # requires node-mimer-native
 ```
 
 ## Architecture
 
-The library has two layers:
-
 ```
 Application (JavaScript)
         |
@@ -592,13 +568,13 @@ JavaScript Wrapper (Promise-based)
   index.js, lib/client.js, lib/prepared.js,
   lib/resultset.js, lib/pool.js
         |
-        | lib/native.js (backend selection)
+        | lib/native.js (loads native addon)
         v
-Koffi FFI Backend (lib/koffi-binding.js)
-  — or —
-node-mimer-native (C++ addon, optional)
+C++ Native Addon (Node-API)
+  src/connection.cc, src/statement.cc,
+  src/resultset.cc, src/helpers.cc
         |
-        | FFI / Node-API calls
+        | C API calls
         v
 Mimer SQL C API (libmimerapi.so)
         |
@@ -606,14 +582,12 @@ Mimer SQL C API (libmimerapi.so)
 Mimer SQL Database
 ```
 
-The Koffi FFI backend (`lib/koffi-binding.js`) calls the Mimer SQL C API
-functions directly using [Koffi](https://koffi.dev/), an FFI library that ships
-its own prebuilt binaries. This means `node-mimer` is a pure JavaScript package
-with no native compilation step.
-
-The optional `node-mimer-native` package provides the same interface using a
-C++ Node-API addon. It can be installed alongside `node-mimer` as a drop-in
-replacement if needed.
+The package ships prebuilt `.node` binaries for supported platforms via
+[prebuildify](https://github.com/prebuild/prebuildify). At install time,
+`prebuild-install` downloads the matching binary. If no prebuilt is available,
+the addon is compiled from source using `node-gyp`. The native addon uses
+[Node-API](https://nodejs.org/api/n-api.html) (N-API v8), so binaries are
+stable across Node.js versions without recompilation.
 
 ### Mimer SQL C API Functions Used
 
@@ -633,18 +607,28 @@ replacement if needed.
 
 ```
 node-mimer/
+├── src/                          # C++ native addon
+│   ├── mimer_addon.cc           # Module entry point
+│   ├── connection.cc/h          # Connection class
+│   ├── statement.cc/h           # Prepared statement class
+│   ├── resultset.cc/h           # Cursor/streaming result set class
+│   └── helpers.cc/h             # Parameter binding, row fetching, errors
+│
 ├── lib/                          # JavaScript modules
-│   ├── native.js                # Backend selection (Koffi or native)
-│   ├── koffi-binding.js         # Koffi FFI backend
-│   ├── find-mimer-library.js    # Platform-specific library detection
+│   ├── native.js                # Loads native addon via node-gyp-build
 │   ├── client.js                # MimerClient, connect()
 │   ├── prepared.js              # PreparedStatement
 │   ├── resultset.js             # ResultSet (cursor wrapper)
 │   └── pool.js                  # Pool, PoolClient
 │
+├── prebuilds/                    # Prebuilt binaries (per platform)
+│   └── linux-x64/               # Example: Linux x64 binary
+│
 ├── scripts/
-│   └── check-mimer.js           # Verify Mimer installation
+│   ├── check-mimer.js           # Verify Mimer installation
+│   └── find-mimer-windows.js    # Auto-detect Mimer on Windows
 │
+├── binding.gyp                   # Native addon build configuration
 ├── index.js                      # Re-exports from lib/
 ├── index.d.ts                    # TypeScript type definitions
 ├── package.json
@@ -667,4 +651,4 @@ Contributions are welcome! Please submit pull requests or open issues on GitHub.
 
 - [Mimer SQL Documentation](https://developer.mimer.com/documentation)
 - [Mimer SQL C API Reference](https://developer.mimer.com/mimerapi)
-- [Koffi FFI Library](https://koffi.dev/)
+- [Node-API Documentation](https://nodejs.org/api/n-api.html)

package/binding.gyp

@@ -0,0 +1,66 @@
+{
+  "targets": [
+    {
+      "target_name": "mimer",
+      "sources": [
+        "src/mimer_addon.cc",
+        "src/connection.cc",
+        "src/statement.cc",
+        "src/helpers.cc",
+        "src/resultset.cc"
+      ],
+      "include_dirs": [
+        "<!@(node -p \"require('node-addon-api').include\")"
+      ],
+      "cflags!": [ "-fno-exceptions" ],
+      "cflags_cc!": [ "-fno-exceptions" ],
+      "defines": [
+        "NAPI_CPP_EXCEPTIONS"
+      ],
+      "conditions": [
+        ["OS=='linux'", {
+          "libraries": [
+            "-lmimerapi"
+          ],
+          "conditions": [
+            ["target_arch=='arm64'", {
+              "libraries": [
+                "-L<!(pwd)/platform_lib/linux-arm64"
+              ]
+            }]
+          ]
+        }],
+        ["OS=='mac'", {
+          "libraries": [
+            "-lmimerapi"
+          ],
+          "xcode_settings": {
+            "GCC_ENABLE_CPP_EXCEPTIONS": "YES",
+            "CLANG_CXX_LIBRARY": "libc++",
+            "MACOSX_DEPLOYMENT_TARGET": "10.15"
+          }
+        }],
+        ["OS=='win'", {
+          "variables": {
+            # Automatically find Mimer SQL installation
+            # Searches for latest version in Program Files
+            # Falls back to "C:\Program Files\Mimer SQL Experience 11.0" if not found
+            "mimer_home": "<!(node scripts/find-mimer-windows.js)"
+          },
+          "include_dirs": [
+            "<(mimer_home)/dev/include"
+          ],
+          "libraries": [
+            "<(mimer_home)/dev/lib/amd64/mimapi64.lib"
+          ],
+          "defines": ["_HAS_EXCEPTIONS=1"],
+          "msvs_settings": {
+            "VCCLCompilerTool": {
+              "ExceptionHandling": 1
+            }
+          }
+        }]
+      ]
+    }
+  ]
+}

package/lib/native.js

@@ -23,30 +23,13 @@
 'use strict';
 
 /**
- * Backend selection for node-mimer.
+ * Load the native Mimer SQL binding.
  *
- * Default: Koffi FFI (pure JS, no compilation needed).
- * If the optional `node-mimer-native` package is installed, it is used instead.
- *
- * Override with NODE_MIMER_BACKEND environment variable:
- *   NODE_MIMER_BACKEND=koffi   — force Koffi FFI backend
- *   NODE_MIMER_BACKEND=native  — force node-mimer-native (C++ addon)
+ * Uses node-gyp-build to find the binary:
+ *   1. prebuilds/<platform>-<arch>/ (shipped in the npm package)
+ *   2. build/Release/ (compiled from source at install time)
  */
 
-let binding;
-const backend = process.env.NODE_MIMER_BACKEND;
-
-if (backend === 'koffi') {
-  binding = require('./koffi-binding');
-} else if (backend === 'native') {
-  binding = require('node-mimer-native');
-} else {
-  // Default: try node-mimer-native if installed, otherwise Koffi
-  try {
-    binding = require('node-mimer-native');
-  } catch {
-    binding = require('./koffi-binding');
-  }
-}
+const path = require('path');
 
-module.exports = binding;
+module.exports = require('node-gyp-build')(path.join(__dirname, '..'));

package/package.json

@@ -1,16 +1,27 @@
 {
   "name": "@mimersql/node-mimer",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Node.js bindings for Mimer SQL using Mimer API",
   "main": "index.js",
   "types": "index.d.ts",
+  "gypfile": true,
   "files": [
     "index.js",
     "index.d.ts",
-    "lib/"
+    "lib/",
+    "src/",
+    "scripts/check-mimer.js",
+    "scripts/find-mimer-windows.js",
+    "binding.gyp",
+    "prebuilds/"
   ],
   "scripts": {
+    "install": "prebuild-install || node-gyp rebuild",
+    "build": "node-gyp rebuild",
     "test": "node --test test/*.test.js",
+    "prebuild": "prebuildify --napi --strip",
+    "prebuild-macos": "prebuildify --napi --strip --arch x64 && prebuildify --napi --strip --arch arm64",
+    "prebuild-linux": "prebuildify --napi --strip && bash scripts/prebuild-linux-arm64.sh",
     "check-mimer": "node scripts/check-mimer.js"
   },
   "keywords": [
@@ -30,9 +41,20 @@
   "author": "Fredrik Ålund <fredrik.alund@mimer.com>",
   "license": "MIT",
   "dependencies": {
-    "koffi": "^2.15.1"
+    "node-addon-api": "^8.0.0",
+    "node-gyp-build": "^4.8.4",
+    "prebuild-install": "^7.1.2"
+  },
+  "devDependencies": {
+    "node-gyp": "^10.0.0",
+    "prebuildify": "^6.0.1"
   },
   "engines": {
     "node": ">=18.0.0"
+  },
+  "binary": {
+    "napi_versions": [
+      8
+    ]
   }
 }

package/scripts/check-mimer.js

@@ -0,0 +1,149 @@
+#!/usr/bin/env node
+/**
+ * Verify Mimer SQL installation and configuration
+ * Run this to check if Mimer SQL can be found before building
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+function checkLinux() {
+  console.log('Checking Mimer SQL on Linux...\n');
+  
+  const locations = [
+    '/usr/include/mimerapi.h',
+    '/usr/lib/libmimerapi.so',
+    '/usr/lib64/libmimerapi.so',
+    '/usr/lib/x86_64-linux-gnu/libmimerapi.so'
+  ];
+  
+  let found = false;
+  for (const loc of locations) {
+    if (fs.existsSync(loc)) {
+      console.log(`✓ Found: ${loc}`);
+      found = true;
+    }
+  }
+  
+  if (!found) {
+    console.log('✗ Mimer SQL not found in standard locations');
+    console.log('  Install with: sudo dpkg -i mimerapi_*.deb');
+    console.log('  or: sudo rpm -i mimerapi-*.rpm');
+    return false;
+  }
+  
+  return true;
+}
+
+function checkMacOS() {
+  console.log('Checking Mimer SQL on macOS...\n');
+  
+  const headerPath = '/usr/local/include/mimerapi.h';
+  const libPath = '/usr/local/lib/libmimerapi.dylib';
+  
+  if (!fs.existsSync(headerPath)) {
+    console.log(`✗ Header not found: ${headerPath}`);
+    console.log('  Install Mimer SQL from https://developer.mimer.com');
+    return false;
+  }
+  console.log(`✓ Found: ${headerPath}`);
+  
+  if (!fs.existsSync(libPath)) {
+    console.log(`✗ Library not found: ${libPath}`);
+    console.log('  Install Mimer SQL from https://developer.mimer.com');
+    return false;
+  }
+  console.log(`✓ Found: ${libPath}`);
+  
+  return true;
+}
+
+function checkWindows() {
+  console.log('Checking Mimer SQL on Windows...\n');
+  
+  // Use the same auto-detection logic as binding.gyp
+  const findMimer = require('./find-mimer-windows.js');
+  
+  let mimerHome;
+  try {
+    mimerHome = require('./find-mimer-windows');
+  } catch (e) {
+    // Execute the script to get output
+    const { execSync } = require('child_process');
+    mimerHome = execSync('node scripts/find-mimer-windows.js', { encoding: 'utf8' }).trim();
+  }
+  
+  console.log(`Detected MIMER_HOME: ${mimerHome}\n`);
+  
+  const headerPath = path.join(mimerHome, 'dev', 'include', 'mimerapi.h');
+  const libPath = path.join(mimerHome, 'dev', 'lib', 'amd64', 'mimapi64.lib');
+  const dllPath = path.join(mimerHome, 'bin', 'mimapi64.dll');
+  
+  let allFound = true;
+  
+  if (!fs.existsSync(headerPath)) {
+    console.log(`✗ Header not found: ${headerPath}`);
+    allFound = false;
+  } else {
+    console.log(`✓ Found: ${headerPath}`);
+  }
+  
+  if (!fs.existsSync(libPath)) {
+    console.log(`✗ Library not found: ${libPath}`);
+    allFound = false;
+  } else {
+    console.log(`✓ Found: ${libPath}`);
+  }
+  
+  if (!fs.existsSync(dllPath)) {
+    console.log(`✗ DLL not found: ${dllPath}`);
+    console.log('  (This may cause runtime errors)');
+  } else {
+    console.log(`✓ Found: ${dllPath}`);
+  }
+  
+  if (!allFound) {
+    console.log('\nTo override auto-detection, set MIMER_HOME:');
+    console.log('  $env:MIMER_HOME="C:\\Program Files\\Mimer SQL Experience 11.0"');
+    return false;
+  }
+  
+  return true;
+}
+
+function main() {
+  console.log('=== Mimer SQL Installation Check ===\n');
+  
+  const platform = os.platform();
+  let success = false;
+  
+  if (platform === 'linux') {
+    success = checkLinux();
+  } else if (platform === 'darwin') {
+    success = checkMacOS();
+  } else if (platform === 'win32') {
+    success = checkWindows();
+  } else {
+    console.log(`Unsupported platform: ${platform}`);
+    process.exit(1);
+  }
+  
+  console.log('\n' + '='.repeat(40));
+  
+  if (success) {
+    console.log('✓ Mimer SQL is properly installed');
+    console.log('  You can now run: npm run build');
+    process.exit(0);
+  } else {
+    console.log('✗ Mimer SQL installation issues detected');
+    console.log('  Please install or configure Mimer SQL before building');
+    process.exit(1);
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { checkLinux, checkMacOS, checkWindows };

package/scripts/find-mimer-windows.js

@@ -0,0 +1,179 @@
+#!/usr/bin/env node
+// Copyright (c) 2026 Mimer Information Technology
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+// See license for more details.
+
+/**
+ * find-mimer-windows.js
+ * Automatically find Mimer SQL installation on Windows
+ * 
+ * Search order:
+ * 1. MIMER_HOME environment variable
+ * 2. Windows Registry
+ * 3. Program Files (latest version)
+ * 4. Default fallback path
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Helper to check if Mimer is installed at path
+function isMimerInstalled(mimerPath) {
+  if (!mimerPath) return false;
+  const headerPath = path.join(mimerPath, 'dev', 'include', 'mimerapi.h');
+  return fs.existsSync(headerPath);
+}
+
+// Try 1: Use MIMER_HOME environment variable
+if (process.env.MIMER_HOME && isMimerInstalled(process.env.MIMER_HOME)) {
+  console.log(process.env.MIMER_HOME);
+  process.exit(0);
+}
+
+// Try 2: Read from Windows Registry
+// Mimer SQL stores each version under HKLM\SOFTWARE\Mimer\Mimer SQL\<version>\PathName
+// e.g. HKLM\SOFTWARE\Mimer\Mimer SQL\11.0\PathName
+// We enumerate all version subkeys and pick the highest version.
+if (process.platform === 'win32') {
+  try {
+    const { execSync } = require('child_process');
+    // List all version subkeys under "Mimer SQL"
+    const regEnum = 'reg query "HKLM\\SOFTWARE\\Mimer\\Mimer SQL" 2>nul';
+    const output = execSync(regEnum, { encoding: 'utf8' });
+
+    const registryVersions = [];
+    for (const line of output.split('\n')) {
+      // Each subkey line looks like: HKEY_LOCAL_MACHINE\SOFTWARE\Mimer\Mimer SQL\11.0
+      const versionMatch = line.match(/Mimer SQL\\(\d+\.\d+)\s*$/);
+      if (versionMatch) {
+        const version = versionMatch[1];
+        try {
+          const pathQuery = `reg query "HKLM\\SOFTWARE\\Mimer\\Mimer SQL\\${version}" /v PathName 2>nul`;
+          const pathOutput = execSync(pathQuery, { encoding: 'utf8' });
+          const pathMatch = pathOutput.match(/PathName\s+REG_SZ\s+(.+)/);
+          if (pathMatch && pathMatch[1]) {
+            const mimerPath = pathMatch[1].trim();
+            if (isMimerInstalled(mimerPath)) {
+              registryVersions.push({ version, path: mimerPath });
+            }
+          }
+        } catch (err) {
+          // Could not read PathName for this version, skip
+        }
+      }
+    }
+
+    // Sort by version descending and use the highest
+    if (registryVersions.length > 0) {
+      registryVersions.sort((a, b) => {
+        const va = a.version.split('.').map(Number);
+        const vb = b.version.split('.').map(Number);
+        if (va[0] !== vb[0]) return vb[0] - va[0];
+        return vb[1] - va[1];
+      });
+      console.log(registryVersions[0].path);
+      process.exit(0);
+    }
+  } catch (err) {
+    // Registry key not found, continue
+  }
+}
+
+// Try 3: Find in Program Files - get highest version
+const programFiles = [
+  process.env.ProgramFiles,
+  process.env['ProgramFiles(x86)']
+].filter(Boolean);
+
+const foundPaths = [];
+
+for (const pf of programFiles) {
+  if (!fs.existsSync(pf)) continue;
+  
+  try {
+    const entries = fs.readdirSync(pf, { withFileTypes: true });
+    
+    for (const entry of entries) {
+      if (entry.isDirectory() && entry.name.startsWith('Mimer SQL Experience')) {
+        const fullPath = path.join(pf, entry.name);
+        if (isMimerInstalled(fullPath)) {
+          foundPaths.push({
+            path: fullPath,
+            name: entry.name,
+            // Extract version for sorting (e.g., "11.0" from "Mimer SQL Experience 11.0")
+            version: entry.name.match(/(\d+\.\d+)/)?.[1] || '0.0'
+          });
+        }
+      }
+    }
+  } catch (err) {
+    // Permission error or directory doesn't exist, continue
+  }
+}
+
+// Sort by version (highest first) and return the first one
+if (foundPaths.length > 0) {
+  foundPaths.sort((a, b) => {
+    const versionA = a.version.split('.').map(Number);
+    const versionB = b.version.split('.').map(Number);
+    
+    // Compare major version
+    if (versionA[0] !== versionB[0]) {
+      return versionB[0] - versionA[0];
+    }
+    // Compare minor version
+    return versionB[1] - versionA[1];
+  });
+  
+  console.log(foundPaths[0].path);
+  process.exit(0);
+}
+
+// Try 4: Common default locations (in order of preference)
+const defaultPaths = [
+  'C:\\Program Files\\Mimer SQL Experience 12.0',
+  'C:\\Program Files\\Mimer SQL Experience 11.0',
+  'C:\\Program Files (x86)\\Mimer SQL Experience 12.0',
+  'C:\\Program Files (x86)\\Mimer SQL Experience 11.0'
+];
+
+for (const defaultPath of defaultPaths) {
+  if (isMimerInstalled(defaultPath)) {
+    console.log(defaultPath);
+    process.exit(0);
+  }
+}
+
+// Not found - output a reasonable default that will give a clear error message
+console.error('ERROR: Mimer SQL installation not found.');
+console.error('Searched:');
+console.error('  1. MIMER_HOME environment variable');
+console.error('  2. Windows Registry (HKLM\\SOFTWARE\\Mimer\\Mimer SQL\\<version>\\PathName)');
+console.error('  3. Program Files directories');
+console.error('  4. Default installation paths');
+console.error('');
+console.error('Please:');
+console.error('  1. Install Mimer SQL from https://developer.mimer.com');
+console.error('  2. Or set MIMER_HOME environment variable to your installation path');
+
+// Output a default path that will fail gracefully
+console.log('C:\\Program Files\\Mimer SQL Experience 11.0');
+process.exit(1);