couchbase 4.2.4 → 4.2.5-dev.2

package/CMakeLists.txt

@@ -1,9 +1,108 @@
 cmake_minimum_required(VERSION 3.17)
 cmake_policy(SET CMP0042 NEW)
 cmake_policy(SET CMP0048 NEW)
+include(FetchContent)
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
+function(download_nodejs_headers)
+  message("Finding Node.js headers SHA for version: ${NODE_RUNTIMEVERSION}")
+  file(DOWNLOAD
+    https://nodejs.org/dist/v${NODE_RUNTIMEVERSION}/SHASUMS256.txt
+    "${CMAKE_CURRENT_BINARY_DIR}/SHASUM256.txt"
+    TLS_VERIFY ON)
+
+  file(READ "${CMAKE_CURRENT_BINARY_DIR}/SHASUM256.txt" HASH_FILE_CONTENT)
+  set(REGEX_CHECK "node-v${NODE_RUNTIMEVERSION}-headers.tar.gz")
+  string(REPLACE "\n" ";" HASH_FILE_CONTENT ${HASH_FILE_CONTENT})
+  FOREACH(HASH ${HASH_FILE_CONTENT})
+    string(FIND ${HASH} ${REGEX_CHECK} FOUND_FILE)
+    if("${FOUND_FILE}" GREATER_EQUAL "0")
+      string(REGEX MATCH
+            "^[0-9a-f]+"
+            CB_NODE_VERSION_SHA256
+            ${HASH})
+      break()
+    endif()
+  ENDFOREACH()
+
+  if(NOT CB_NODE_VERSION_SHA256)
+    message(FATAL_ERROR "Failed to extract expected hash from node shasum file.")
+  else()
+    message("Using SHA=${CB_NODE_VERSION_SHA256}")
+  endif()
+  if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.24.0")
+    # see https://cmake.org/cmake/help/latest/policy/CMP0135.html
+    # and Externalproject_add - DOWNLOAD_EXTRACT_TIMESTAMP
+    FetchContent_Declare(
+      nodejs_headers
+      URL https://nodejs.org/dist/v${NODE_RUNTIMEVERSION}/node-v${NODE_RUNTIMEVERSION}-headers.tar.gz
+      URL_HASH SHA256=${CB_NODE_VERSION_SHA256}
+      DOWNLOAD_EXTRACT_TIMESTAMP FALSE
+      )
+  else()
+    FetchContent_Declare(
+      nodejs_headers
+      URL https://nodejs.org/dist/v${NODE_RUNTIMEVERSION}/node-v${NODE_RUNTIMEVERSION}-headers.tar.gz
+      URL_HASH SHA256=${CB_NODE_VERSION_SHA256}
+      )  
+  endif()
+  
+  message("Downloading Node.js ${NODE_RUNTIMEVERSION} headers...")
+  FetchContent_MakeAvailable(nodejs_headers)
+  message("Downloaded Node.js ${NODE_RUNTIMEVERSION} headers to ${nodejs_headers_SOURCE_DIR}")
+  set(NODEJS_INC_DIR "${nodejs_headers_SOURCE_DIR}/include/node" PARENT_SCOPE)
+endfunction()
+
+function(download_nodejs_win_lib)
+  if(NODE_RUNTIME STREQUAL "electron")
+    set(NODE_LIB_URL "https://artifacts.electronjs.org/headers/dist/v${NODE_RUNTIMEVERSION}")
+    if(NODE_ARCH STREQUAL "x64")
+      set(NODE_LIB_URL "${NODE_LIB_URL}/x64")
+    endif()
+  else()
+    set(NODE_LIB_URL "https://nodejs.org/dist/v${NODE_RUNTIMEVERSION}")
+    if(NODE_ARCH STREQUAL "x64")
+      set(NODE_LIB_URL "${NODE_LIB_URL}/win-x64")
+    else()
+      set(NODE_LIB_URL "${NODE_LIB_URL}/win-x86")
+    endif()
+  endif()
+  set(NODE_LIB_URL "${NODE_LIB_URL}/node.lib")
+  
+  FetchContent_Declare(
+    nodejs_win_lib
+    URL ${NODE_LIB_URL}
+    DOWNLOAD_NO_EXTRACT TRUE
+    )
+
+  message("Downloading ${NODE_RUNTIME} v${NODE_RUNTIMEVERSION} win lib...")
+  FetchContent_MakeAvailable(nodejs_win_lib)
+  message("Downloaded ${NODE_RUNTIME} v${NODE_RUNTIMEVERSION} win lib to ${nodejs_win_lib_SOURCE_DIR}")
+  set(NODEJS_LIB "${nodejs_win_lib_SOURCE_DIR}/node.lib" PARENT_SCOPE)
+endfunction()
+
+# cmake-js >= v7.0 no longer downloads the full Node.js Windows lib and utilizes the https://github.com/nodejs/node-api-headers
+# project to build the lib.  Since we rely on OpenSSL we need to pull in more than just the node-api headers, so lets download
+# the node.lib ourselves.
+if(WIN32 AND CMAKE_JS_VERSION VERSION_GREATER_EQUAL "7.0.0")
+  SET(NODEJS_LIB "")
+  download_nodejs_win_lib()
+else()
+  SET(NODEJS_LIB "${CMAKE_JS_LIB}")
+endif()
+
+if(CMAKE_JS_VERSION VERSION_GREATER_EQUAL "7.0.0")
+  set(NODEJS_INC_DIR "")
+  download_nodejs_headers()
+  set(NODEJS_INC_DIR "${NODEJS_INC_DIR};${CMAKE_JS_INC}")
+else()
+  set(NODEJS_INC_DIR "${CMAKE_JS_INC}")
+endif()
+
+message(STATUS "NODEJS_INC_DIR=${NODEJS_INC_DIR}")
+message(STATUS "NODEJS_LIB=${NODEJS_LIB}")
+
 # Set up some build requirements for Windows.
 set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
 if(WIN32)
@@ -13,12 +112,12 @@ endif()
 
 # We need to import this globally in order for OpenSSL to be available
 # to our dependant libraries such as couchbase-cxx-client.
-include_directories(${CMAKE_JS_INC})
+include_directories(${NODEJS_INC_DIR})
 
 set(COUCHBASE_CXX_CLIENT_BUILD_TESTS OFF CACHE BOOL "" FORCE)
 set(COUCHBASE_CXX_CLIENT_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
 set(COUCHBASE_CXX_CLIENT_BUILD_TOOLS OFF CACHE BOOL "" FORCE)
-set(COUCHBASE_CXX_CLIENT_POST_LINKED_OPENSSL ON CACHE BOOL "" FORCE)
+set(COUCHBASE_CXX_CLIENT_POST_LINKED_OPENSSL ON CACHE BOOL "")
 set(COUCHBASE_CXX_CLIENT_STATIC_STDLIB ON CACHE BOOL "" FORCE)
 add_subdirectory(deps/couchbase-cxx-client)
 
@@ -28,20 +127,46 @@ file(GLOB SOURCE_FILES "src/*.cpp")
 add_library(${PROJECT_NAME} SHARED ${SOURCE_FILES} ${CMAKE_JS_SRC})
 
 add_definitions(-DNAPI_VERSION=6)
-target_include_directories(${PROJECT_NAME}
-  PRIVATE ${CMAKE_JS_INC}
-          "${CMAKE_SOURCE_DIR}/node_modules/node-addon-api"
-          "deps/couchbase-cxx-client/include"
-          "deps/couchbase-cxx-client/third_party/asio/asio/include")
+if(CMAKE_JS_VERSION VERSION_GREATER_EQUAL "7.0.0")
+  target_include_directories(${PROJECT_NAME}
+    PRIVATE ${NODEJS_INC_DIR}
+            "deps/couchbase-cxx-client/include"
+            "deps/couchbase-cxx-client/third_party/asio/asio/include")
+else()
+  execute_process(COMMAND node -p "require('node-addon-api').include"
+          WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+          OUTPUT_VARIABLE NODE_ADDON_API_DIR
+          )
+  string(REPLACE "\n" "" NODE_ADDON_API_DIR ${NODE_ADDON_API_DIR})
+  string(REPLACE "\"" "" NODE_ADDON_API_DIR ${NODE_ADDON_API_DIR})
+
+  target_include_directories(${PROJECT_NAME}
+    PRIVATE ${NODEJS_INC_DIR}
+            ${NODE_ADDON_API_DIR}
+            "deps/couchbase-cxx-client/include"
+            "deps/couchbase-cxx-client/third_party/asio/asio/include")
+endif()
 set_target_properties(${PROJECT_NAME} PROPERTIES PREFIX "" SUFFIX ".node")
 
 target_link_libraries(${PROJECT_NAME}
-  ${CMAKE_JS_LIB}
+  ${NODEJS_LIB}
   couchbase_cxx_client
 )
 
-# Workaround a bug in cmake-js with removal of used references:
-# https://github.com/cmake-js/cmake-js/issues/205
-if(MSVC)
+if(MSVC)    
+    # Workaround a bug in cmake-js with removal of used references:
+    # https://github.com/cmake-js/cmake-js/issues/205
     target_link_options(${PROJECT_NAME} PUBLIC /OPT:NOREF)
+
+    # since we only care about the *.PDB for a command line build, this _should_ be okay.
+    if(CMAKE_BUILD_TYPE STREQUAL "Release")
+        target_compile_options(${PROJECT_NAME} PUBLIC /Zi)
+
+        # Do we want /OPT:ICF?
+        set_target_properties(${PROJECT_NAME} PROPERTIES
+          LINK_FLAGS "/INCREMENTAL:NO /DEBUG"
+          COMPILE_PDB_NAME ${PROJECT_NAME} 
+          COMPILE_PDB_OUTPUT_DIR ${CMAKE_BINARY_DIR}
+        )
+    endif()
 endif()

package/dist/binding.js

@@ -9,7 +9,7 @@ eslint
 jsdoc/require-jsdoc: off,
 @typescript-eslint/no-empty-interface: off
 */
-const bindings_1 = __importDefault(require("bindings"));
+const path_1 = __importDefault(require("path"));
 exports.zeroCas = 0;
 //#region Autogenerated Bindings
 var CppManagementAnalyticsCouchbaseLinkEncryptionLevel;
@@ -157,5 +157,6 @@ var CppTxnExternalException;
 (function (CppTxnExternalException) {
 })(CppTxnExternalException = exports.CppTxnExternalException || (exports.CppTxnExternalException = {}));
 // Load it with require
-const binding = (0, bindings_1.default)('couchbase_impl');
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const binding = require('../scripts/prebuilds').loadPrebuild(path_1.default.resolve(__dirname, '..'));
 exports.default = binding;

package/package.json

@@ -1 +1,96 @@
-{"bugs":{"url":"http://www.couchbase.com/issues/browse/JSCBC"},"description":"The official Couchbase Node.js Client Library.","engines":{"node":">=12.0.0"},"homepage":"http://www.couchbase.com/communities/nodejs","keywords":["couchbase","libcouchbase","memcached","nosql","json","document"],"main":"dist/couchbase.js","types":"dist/couchbase.d.ts","license":"Apache-2.0","name":"couchbase","dependencies":{"bindings":"^1.5.0","cmake-js":"^6.3.2","node-addon-api":"^5.0.0","prebuild-install":"^7.1.1"},"devDependencies":{"@trivago/prettier-plugin-sort-imports":"^4.1.0","@tsconfig/node12":"^1.0.11","@types/bindings":"^1.5.1","@types/debug":"^4.1.7","@types/node":"^20.1.0","@typescript-eslint/eslint-plugin":"^5.32.0","@typescript-eslint/parser":"^5.32.0","chai":"^4.3.6","eslint":"^8.21.0","eslint-config-prettier":"^8.5.0","eslint-plugin-jsdoc":"^41.1.0","eslint-plugin-mocha":"^10.1.0","eslint-plugin-node":"^11.1.0","expose-gc":"^1.0.0","mocha":"^10.0.0","npm-check-updates":"^16.0.5","nyc":"^15.1.0","prebuild":"^11.0.4","prettier":"^2.7.1","segfault-handler":"^1.3.0","semver":"^7.3.7","ts-mocha":"^10.0.0","ts-node":"^10.9.1","typedoc":"^0.24.1","typescript":"^4.7.4","uuid":"^9.0.0"},"repository":{"type":"git","url":"http://github.com/couchbase/couchnode.git"},"version":"4.2.4","config":{"native":false},"scripts":{"install":"prebuild-install -r napi || cmake-js compile","build":"cmake-js build && tsc","rebuild":"cmake-js rebuild && tsc","prebuild":"prebuild --backend cmake-js --verbose --strip","prepare":"tsc","build-docs":"typedoc","test":"ts-mocha test/*.test.*","test-fast":"ts-mocha test/*.test.* -ig '(slow)'","cover":"nyc ts-mocha test/*.test.*","cover-fast":"nyc ts-mocha test/*.test.* -ig '(slow)'","lint":"eslint ./lib/ ./test/","check-deps":"ncu"},"binary":{"napi_versions":[6]}}
+{
+  "bugs": {
+    "url": "http://www.couchbase.com/issues/browse/JSCBC"
+  },
+  "description": "The official Couchbase Node.js Client Library.",
+  "engines": {
+    "node": ">=12.0.0"
+  },
+  "homepage": "http://www.couchbase.com/communities/nodejs",
+  "keywords": [
+    "couchbase",
+    "libcouchbase",
+    "memcached",
+    "nosql",
+    "json",
+    "document"
+  ],
+  "main": "dist/couchbase.js",
+  "types": "dist/couchbase.d.ts",
+  "license": "Apache-2.0",
+  "name": "couchbase",
+  "dependencies": {
+    "cmake-js": "^7.2.0",
+    "node-addon-api": "^5.0.0"
+  },
+  "devDependencies": {
+    "@trivago/prettier-plugin-sort-imports": "^4.1.0",
+    "@types/bindings": "^1.5.1",
+    "@types/debug": "^4.1.7",
+    "@types/node": "^20.1.0",
+    "@tsconfig/node12": "^1.0.11",
+    "@typescript-eslint/eslint-plugin": "^5.32.0",
+    "@typescript-eslint/parser": "^5.32.0",
+    "chai": "^4.3.6",
+    "eslint": "^8.21.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-jsdoc": "^41.1.0",
+    "eslint-plugin-mocha": "^10.1.0",
+    "eslint-plugin-node": "^11.1.0",
+    "expose-gc": "^1.0.0",
+    "mocha": "^10.0.0",
+    "npm-check-updates": "^16.0.5",
+    "nyc": "^15.1.0",
+    "prebuild": "^11.0.4",
+    "prettier": "^2.7.1",
+    "segfault-handler": "^1.3.0",
+    "semver": "^7.3.7",
+    "ts-mocha": "^10.0.0",
+    "ts-node": "^10.9.1",
+    "typedoc": "^0.24.1",
+    "typescript": "^4.7.4",
+    "uuid": "^9.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "http://github.com/couchbase/couchnode.git"
+  },
+  "version": "4.2.5-dev.2",
+  "config": {
+    "native": false
+  },
+  "scripts": {
+    "install": "node ./scripts/install.js",
+    "build": "cmake-js build && tsc",
+    "rebuild": "cmake-js rebuild && tsc",
+    "prebuild": "prebuild --backend cmake-js --verbose --strip",
+    "prepare": "tsc",
+    "help-prune": "node ./scripts/prune.js",
+    "build-docs": "typedoc",
+    "test": "ts-mocha test/*.test.*",
+    "test-fast": "ts-mocha test/*.test.* -ig '(slow)'",
+    "cover": "nyc ts-mocha test/*.test.*",
+    "cover-fast": "nyc ts-mocha test/*.test.* -ig '(slow)'",
+    "lint": "eslint ./lib/ ./test/",
+    "check-deps": "ncu"
+  },
+  "binary": {
+    "napi_versions": [
+      6
+    ]
+  },
+  "optionalDependencies": {
+    "@couchbase/couchbase-darwin-arm64-openssl1": "4.2.5-dev.2",
+    "@couchbase/couchbase-darwin-arm64-openssl3": "4.2.5-dev.2",
+    "@couchbase/couchbase-darwin-x64-openssl1": "4.2.5-dev.2",
+    "@couchbase/couchbase-darwin-x64-openssl3": "4.2.5-dev.2",
+    "@couchbase/couchbase-linux-arm64-openssl1": "4.2.5-dev.2",
+    "@couchbase/couchbase-linux-arm64-openssl3": "4.2.5-dev.2",
+    "@couchbase/couchbase-linux-x64-openssl1": "4.2.5-dev.2",
+    "@couchbase/couchbase-linux-x64-openssl3": "4.2.5-dev.2",
+    "@couchbase/couchbase-linuxmusl-x64-openssl1": "4.2.5-dev.2",
+    "@couchbase/couchbase-linuxmusl-x64-openssl3": "4.2.5-dev.2",
+    "@couchbase/couchbase-win32-x64-openssl1": "4.2.5-dev.2",
+    "@couchbase/couchbase-win32-x64-openssl3": "4.2.5-dev.2"
+  }
+}

package/scripts/createPlatformPackages.js

@@ -0,0 +1,108 @@
+const fs = require('fs')
+const path = require('path')
+const { getSupportedPlatformPackages } = require('./prebuilds')
+
+try {
+  // we run this script w/in a Jenkins dir("couchnode"){} block
+  const couchbasePkgData = JSON.parse(fs.readFileSync('package.json'))
+  const packageName = couchbasePkgData.name
+  const packageVersion = couchbasePkgData.version
+  let platformPackages = (couchbasePkgData.optionalDependencies = {})
+  const prebuildsPath = path.join(process.cwd(), 'prebuilds')
+  const prebuilds = fs.readdirSync(prebuildsPath)
+  const supportedPlatPkgs = getSupportedPlatformPackages(couchbasePkgData.name)
+  for (const prebuild of prebuilds) {
+    if (fs.lstatSync(path.join(prebuildsPath, prebuild)).isDirectory()) continue
+    // prebuild format:
+    //   couchbase-v<pkg-version>-<runtime>-v<runtime-version>-<platform>-<arch>-<SSL type>.node.tar.gz
+    const tokens = prebuild.split('-')
+    if (tokens.length < 7) continue
+    if (tokens[tokens.length - 1].startsWith('debug')) {
+      fs.renameSync(`prebuilds/${prebuild}`, `prebuilds_debug/${prebuild}`)
+      continue
+    }
+    const nodeVersion = parseInt(
+      tokens[tokens.length - 1].replace('.node', '').replace('node', '')
+    )
+    const arch = tokens[tokens.length - 2]
+    const platform = tokens[tokens.length - 3]
+    const runtime = tokens[tokens.length - 5]
+    const sslType =
+      runtime === 'napi'
+        ? nodeVersion >= 18
+          ? 'openssl3'
+          : 'openssl1'
+        : 'boringssl'
+    const platPkg = `${tokens[0]}-${platform}-${arch}-${sslType}`
+    let description = `Couchbase Node.js SDK platform specific binary for ${runtime} runtime on ${platform} OS with ${arch} architecture`
+    if (runtime === 'napi') {
+      description += ` and OpenSSL ${nodeVersion >= 18 ? '3.x' : '1.x'}.`
+    } else {
+      description += ' and BoringSSL.'
+    }
+    console.log(`platformPackage=${platPkg}`)
+    if (supportedPlatPkgs.includes(platPkg)) {
+      console.log(`Building requirements for platform package: ${platPkg}`)
+      if (!fs.existsSync(`prebuilds/${platPkg}`)) {
+        fs.mkdirSync(`prebuilds/${platPkg}`)
+      }
+      tokens[tokens.length - 1] = `${sslType}.node`
+      const newPrebuildName = tokens.join('-')
+      const oldPath = path.join('prebuilds', prebuild)
+      const newPath = path.join('prebuilds', platPkg)
+      fs.renameSync(oldPath, path.join(newPath, newPrebuildName))
+      const platformPackage = `@${packageName}/${platPkg}`
+      // build the platform package files: package.json, README and index.js
+      const engines = { node: `>=16.0.0` }
+      if (runtime === 'napi') {
+        engines.node = nodeVersion >= 18 ? '>=18.0.0' : '<18'
+      }
+      fs.writeFileSync(
+        path.join(newPath, 'package.json'),
+        JSON.stringify(
+          {
+            name: platformPackage,
+            version: packageVersion,
+            engines: engines,
+            os: [platform.includes('linux') ? 'linux' : platform],
+            cpu: [arch],
+            bugs: couchbasePkgData.bugs,
+            homepage: couchbasePkgData.homepage,
+            license: couchbasePkgData.license,
+            repository: couchbasePkgData.repository,
+            description: description,
+          },
+          null,
+          2
+        )
+      )
+      fs.writeFileSync(path.join(newPath, 'index.js'), '')
+      fs.writeFileSync(path.join(newPath, 'README.md'), description)
+      platformPackages[platformPackage] = packageVersion
+    }
+  }
+
+  if (
+    !process.env.ALLOW_MISMATCH &&
+    Object.keys(platformPackages).length != supportedPlatPkgs.length
+  ) {
+    const builtPlatformPkgs = Object.keys(platformPackages).map((pkg) => {
+      const tokens = pkg.split('/')
+      return tokens[1]
+    })
+    const missingPkgs = supportedPlatPkgs.filter(
+      (pkg) => !builtPlatformPkgs.includes(pkg)
+    )
+    const extraPkgs = builtPlatformPkgs.filter(
+      (pkg) => !supportedPlatPkgs.includes(pkg)
+    )
+    let msg = 'Mismatch in built platform packages.\n'
+    msg += 'Missing: ' + JSON.stringify(missingPkgs) + '.\n'
+    msg += 'Extra: ' + JSON.stringify(extraPkgs) + '.'
+    throw new Error(msg)
+  }
+  fs.writeFileSync('package.json', JSON.stringify(couchbasePkgData, null, 2))
+} catch (err) {
+  console.log('An error occurred:', err)
+  process.exitCode = 1
+}

package/scripts/install.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+
+const path = require('path')
+var proc = require('child_process')
+const prebuilds = require('./prebuilds')
+
+if (hasLocalPrebuild()) {
+  const destination = path.join(
+    path.resolve(__dirname, '..'),
+    'build',
+    'Release'
+  )
+  const source = getLocalPrebuild()
+  // on either success or failure of resolving local prebuild we still confirm we have a prebuild
+  prebuilds.resolveLocalPrebuild(source, destination).then(installPrebuild())
+} else {
+  installPrebuild()
+}
+
+function getLocalPrebuild() {
+  const localPrebuildsName = `npm_config_couchbase_local_prebuilds`
+  return process.env[localPrebuildsName]
+}
+
+function hasLocalPrebuild() {
+  return typeof getLocalPrebuild() === 'string'
+}
+
+function installPrebuild() {
+  try {
+    prebuilds.resolvePrebuild(path.resolve(__dirname, '..'), false)
+    process.exit(0)
+  } catch (err) {
+    const cmakejs = path.join(
+      require.resolve('cmake-js/package.json'),
+      '..',
+      require('cmake-js/package.json').bin['cmake-js']
+    )
+    // @TODO: is spawning sync a problem? Seemed to be easiest way to get Ctrl-C to kill the whole build process
+    const cmakejsProc = proc.spawnSync(process.execPath, [cmakejs, 'compile'], {
+      stdio: 'inherit',
+    })
+    process.exit(cmakejsProc.status)
+  }
+}

package/scripts/prebuilds.js

@@ -0,0 +1,249 @@
+const fs = require('fs')
+const path = require('path')
+const zlib = require('zlib')
+const stream = require('stream')
+const { promisify } = require('util')
+const pipe = promisify(stream.pipeline)
+
+// Workaround to fix webpack's build warnings: 'the request of a dependency is an expression'
+const runtimeRequire =
+  typeof __webpack_require__ === 'function' ? __non_webpack_require__ : require
+
+const openSSLVersions = ['openssl1', 'openssl3']
+const supportedPlatforms = ['darwin', 'linux', 'linuxmusl', 'win32']
+const supportedArches = ['x64', 'arm64']
+
+const runtime = isElectron() ? 'electron' : 'node'
+const nodeVersion = getNodeVersion()
+const nodeVersionMajor = getNodeMajorVersion(nodeVersion)
+const arch = process.arch
+const platform = process.platform
+const libc = getLinuxType(platform)
+const sslType = getSSLType(runtime, nodeVersion)
+
+function getLocalPrebuild(dir) {
+  const localPrebuildDir = path.join(dir, 'build/Release')
+  const files = readdirSync(localPrebuildDir).filter(matchBuild)
+  return files[0] && path.join(localPrebuildDir, files[0])
+}
+
+function getLinuxType(platform) {
+  if (platform !== 'linux') {
+    return ''
+  }
+  return `linux${isAlpine(platform) ? 'musl' : ''}`
+}
+
+function getNodeMajorVersion(version) {
+  const tokens = version.split('.')
+  return parseInt(tokens[0])
+}
+
+function getNodeVersion() {
+  return process.version.replace('v', '')
+}
+
+function getPrebuildsInfo(dir) {
+  dir = path.resolve(dir || '.')
+  const info = {
+    packageDir: path.join(dir, 'package.json'),
+    platformPackageDir: undefined,
+  }
+
+  const packageName = JSON.parse(fs.readFileSync(info.packageDir)).name
+  if (packageName !== undefined) {
+    const allowedPlatformPkg = `${packageName}-${
+      platform === 'linux' ? libc : platform
+    }-${arch}-${sslType}`
+    const fullPlatformPkgName = `@${packageName}/${allowedPlatformPkg}`
+    const packageRequire = require('module').createRequire(
+      path.join(dir, 'package.json')
+    )
+    info.packageDir = path.dirname(path.join(dir, 'package.json'))
+    info.platformPackageDir = path.dirname(
+      packageRequire.resolve(fullPlatformPkgName)
+    )
+  }
+  return info
+}
+
+function getSSLType(runtime, version) {
+  if (runtime === 'electron') {
+    return 'boringssl'
+  }
+
+  const major = getNodeMajorVersion(version)
+  if (major >= 18) {
+    return 'openssl3'
+  }
+  return 'openssl1'
+}
+
+function getSupportedPlatformPackages(packageName) {
+  packageName = packageName || 'couchbase'
+  if (packageName !== 'couchbase') {
+    throw new Error(
+      'Cannot build supported platform packages for package other than couchbase.'
+    )
+  }
+
+  const packageNames = []
+  // format: <platform>-<arch>-<runtime>-<SSL Type>
+  supportedPlatforms.forEach((plat) => {
+    supportedArches.forEach((arch) => {
+      if (plat === 'win32' && arch === 'arm64') return
+      openSSLVersions.forEach((ssl) => {
+        packageNames.push(`${packageName}-${plat}-${arch}-${ssl}`)
+      })
+      packageNames.push(`${packageName}-${plat}-${arch}-boringssl`)
+    })
+  })
+  return packageNames
+}
+
+function isAlpine(platform) {
+  return platform === 'linux' && fs.existsSync('/etc/alpine-release')
+}
+
+function isElectron() {
+  if (process.versions && process.versions.electron) return true
+  if (process.env.ELECTRON_RUN_AS_NODE) return true
+  return (
+    typeof window !== 'undefined' &&
+    window.process &&
+    window.process.type === 'renderer'
+  )
+}
+
+function loadPrebuild(dir) {
+  return runtimeRequire(resolvePrebuild(dir))
+}
+
+function matchBuild(name) {
+  return /\.node$/.test(name)
+}
+
+function matchingPlatformPrebuild(filename) {
+  if (['index.js', 'package.json', 'README.md'].includes(filename)) {
+    return false
+  }
+  const tokens = filename.split('-')
+  // filename format:
+  //   couchbase-v<pkg-version>-<runtime>-v<runtime-version>-<platform>-<arch>-<ssltype>.node
+  if (tokens.length < 7) return false
+  const prebuildSSL = tokens[tokens.length - 1].replace('.node', '')
+  if (runtime === 'electron') {
+    if (prebuildSSL !== 'boringssl') return false
+  } else {
+    if (nodeVersionMajor >= 18 && prebuildSSL !== 'openssl3') return false
+    if (nodeVersionMajor < 18 && prebuildSSL !== 'openssl1') return false
+  }
+  if (tokens[tokens.length - 2] !== arch) return false
+  const platCompare = platform === 'linux' ? libc : platform
+  if (tokens[tokens.length - 3] !== platCompare) return false
+  if (!matchBuild(filename)) return false
+  // yay -- found a match!
+  return true
+}
+
+function matchPrebuild(name) {
+  return /\.tar\.gz$/.test(name) || matchBuild(name)
+}
+
+function readdirSync(dir) {
+  try {
+    return fs.readdirSync(dir)
+  } catch (err) {
+    return []
+  }
+}
+
+async function resolveLocalPrebuild(src, dest) {
+  if (fs.existsSync(src)) {
+    const prebuilds = readdirSync(src).filter(matchPrebuild)
+    if (prebuilds && prebuilds.length >= 1) {
+      if (!fs.existsSync(dest)) {
+        fs.mkdirSync(dest, { recursive: true })
+      }
+      const prebuild = prebuilds[0]
+      let prebuildDestName = prebuild
+      if (prebuild.endsWith('.tar.gz')) {
+        const gzip = zlib.createGunzip()
+        const source = fs.createReadStream(src)
+        prebuildDestName = `${prebuild.substring(0, prebuild.length - 7)}.node`
+        const destination = fs.createWriteStream(
+          path.join(src, prebuildDestName)
+        )
+        await pipe(source, gzip, destination)
+      }
+      try {
+        fs.copyFileSync(
+          path.join(src, prebuild),
+          path.join(dest, prebuildDestName)
+        )
+      } catch (_) {}
+    }
+  }
+}
+
+function resolvePrebuild(dir, runtimeResolve = true) {
+  dir = path.resolve(dir || '.')
+  try {
+    const localPrebuild = getLocalPrebuild(dir)
+    if (localPrebuild) {
+      return localPrebuild
+    }
+
+    const packageName = runtimeResolve
+      ? runtimeRequire(path.join(dir, 'package.json')).name
+      : JSON.parse(fs.readFileSync(path.join(dir, 'package.json'))).name
+    if (packageName !== undefined) {
+      const supportedPackages = getSupportedPlatformPackages(packageName)
+      const platformPkg = `${packageName}-${
+        platform === 'linux' ? libc : platform
+      }-${arch}-${sslType}`
+      if (supportedPackages.includes(platformPkg)) {
+        const fullPlatformPkgName = `@${packageName}/${platformPkg}`
+        const packageRequire = require('module').createRequire(
+          path.join(dir, 'package.json')
+        )
+        const platformPackagesDir = path.dirname(
+          packageRequire.resolve(fullPlatformPkgName)
+        )
+        if (platformPackagesDir !== undefined) {
+          const platformPrebuild = readdirSync(platformPackagesDir).filter(
+            matchingPlatformPrebuild
+          )
+          if (platformPrebuild && platformPrebuild.length == 1) {
+            return path.join(platformPackagesDir, platformPrebuild[0])
+          }
+        }
+      }
+    }
+  } catch (_) {}
+
+  let target = [
+    `platform=${platform}`,
+    `arch=${arch}`,
+    `runtime=${runtime}`,
+    `nodeVersion=${nodeVersion}`,
+    `sslType=${sslType}`,
+  ]
+  if (libc) {
+    target.push(`libc=${libc}`)
+  }
+  if (typeof __webpack_require__ === 'function') {
+    target.push('webpack=true')
+  }
+  throw new Error(
+    `Could not find native build for ${target.join(', ')} loaded from ${dir}.`
+  )
+}
+
+module.exports = {
+  getPrebuildsInfo,
+  getSupportedPlatformPackages,
+  loadPrebuild,
+  resolveLocalPrebuild,
+  resolvePrebuild,
+}

package/scripts/prune.js

@@ -0,0 +1,124 @@
+const fs = require('fs')
+const path = require('path')
+const prebuilds = require('./prebuilds')
+
+function getMismatchedPlatformPackagesInfo(
+  platformPackagesDir,
+  expectedPlatformPackage
+) {
+  let message = `Checking for platform packages in ${platformPackagesDir} `
+  message += `that do not match the expected platform package (${expectedPlatformPackage}).`
+  console.log(message)
+  let mismatches = []
+  try {
+    const files = fs.readdirSync(platformPackagesDir)
+    files.forEach((file) => {
+      if (file === expectedPlatformPackage) {
+        return
+      }
+      const stats = fs.statSync(path.join(platformPackagesDir, file))
+      if (!stats.isDirectory()) {
+        return
+      }
+      const filePath = path.join(platformPackagesDir, file)
+      const size = getDirectorySize(filePath)
+      console.log(`Found mismatch: Path=${filePath}`)
+      const platformPackage = path.basename(filePath)
+      mismatches.push({
+        name: platformPackage,
+        dir: filePath,
+        size: size,
+      })
+    })
+  } catch (err) {
+    console.error(`Error trying to delete mismatched platform packages.`, err)
+  }
+  return mismatches
+}
+
+function getDirectorySize(dir) {
+  let size = 0
+  const dirContents = fs.readdirSync(dir)
+  dirContents.forEach((content) => {
+    const contentPath = path.join(dir, content)
+    const stats = fs.statSync(contentPath)
+    if (stats.isFile()) {
+      size += stats.size
+    } else if (stats.isDirectory()) {
+      size += getDirectorySize(contentPath)
+    }
+  })
+
+  return size
+}
+
+function getPrebuildsInfo() {
+  try {
+    const prebuildsInfo = prebuilds.getPrebuildsInfo()
+    return prebuildsInfo
+  } catch (err) {
+    console.error('Error trying to obtain couchbase prebuilds info.', err)
+    return undefined
+  }
+}
+
+function pruneCouchbaseHelp() {
+  const prebuildsInfo = getPrebuildsInfo()
+  const platformPackagesDir = path.dirname(prebuildsInfo.platformPackageDir)
+  const expectedPlatformPackage = path.basename(
+    prebuildsInfo.platformPackageDir
+  )
+
+  const mismatchedPlatPkgs = getMismatchedPlatformPackagesInfo(
+    platformPackagesDir,
+    expectedPlatformPackage
+  )
+  const cbDeps = {
+    dir: path.join(prebuildsInfo.packageDir, 'deps'),
+    size: undefined,
+  }
+  const cbSrc = {
+    dir: path.join(prebuildsInfo.packageDir, 'src'),
+    size: undefined,
+  }
+  try {
+    cbDeps.size = getDirectorySize(cbDeps.dir)
+  } catch (_) {
+    console.log('Couchbase deps/ not found.')
+  }
+  try {
+    cbSrc.size = getDirectorySize(cbSrc.dir)
+  } catch (_) {
+    console.log('Couchbase src/ not found.')
+  }
+
+  console.log('\nRecommendations for pruning:\n')
+  if (mismatchedPlatPkgs.length > 0) {
+    for (const pkg of mismatchedPlatPkgs) {
+      const sizeMb = pkg.size / 1024 / 1024
+      console.log(
+        `Removing mismatched platform=${pkg.name} (path=${
+          pkg.dir
+        }) saves ~${sizeMb.toFixed(2)} MB on disk.`
+      )
+    }
+  }
+  if (cbDeps.size) {
+    const sizeMb = cbDeps.size / 1024 / 1024
+    console.log(
+      `Removing Couchbase deps/ (path=${cbDeps.dir}) saves ~${sizeMb.toFixed(
+        2
+      )} MB on disk.`
+    )
+  }
+  if (cbSrc.size) {
+    const sizeMb = cbSrc.size / 1024 / 1024
+    console.log(
+      `Removing Couchbase src/ (path=${cbSrc.dir}) saves ~${sizeMb.toFixed(
+        2
+      )} MB on disk.`
+    )
+  }
+}
+
+pruneCouchbaseHelp()