fixed testing

.github/workflows/build-node-wrapper/action.yml

@@ -80,6 +80,6 @@ runs:
           working-directory: ./node
           run: |
               source "$HOME/.cargo/env"
-              TARGET_FLAG=`if [ "${{ inputs.target }}" != ''  ]; then echo "--target ${{ inputs.target }}"; fi`
+              # TARGET_FLAG=`if [ "${{ inputs.target }}" != ''  ]; then echo "--target ${{ inputs.target }}"; fi`
               BUILD_FLAG=`if [ "${{ inputs.publish }}" == 'true' ]; then echo "build:release"; else echo "build"; fi`
-              npm run $BUILD_FLAG --build-flags="$TARGET_FLAG"
+              npm run $BUILD_FLAG

node/rust-client/aarch64-unknown-linux-gnu/index.d.ts

@@ -0,0 +1,64 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/* auto-generated by NAPI-RS */
+
+export const enum Level {
+    Debug = 3,
+    Error = 0,
+    Info = 2,
+    Trace = 4,
+    Warn = 1,
+}
+export const MAX_REQUEST_ARGS_LEN: number
+export const DEFAULT_TIMEOUT_IN_MILLISECONDS: number
+export function StartSocketConnection(): Promise<string>
+export function log(logLevel: Level, logIdentifier: string, message: string): void
+export function InitInternalLogger(level?: Level | undefined | null, fileName?: string | undefined | null): Level
+export function valueFromSplitPointer(
+    highBits: number,
+    lowBits: number,
+): null | string | number | {} | Boolean | BigInt | Set<any> | any[]
+/**
+ * This function is for tests that require a value allocated on the heap.
+ * Should NOT be used in production.
+ */
+export function createLeakedString(message: string): [number, number]
+export function createLeakedStringVec(message: Array<Uint8Array>): [number, number]
+/**
+ * This function is for tests that require a value allocated on the heap.
+ * Should NOT be used in production.
+ */
+export function createLeakedMap(map: Record<string, string>): [number, number]
+/**
+ * This function is for tests that require a value allocated on the heap.
+ * Should NOT be used in production.
+ */
+export function createLeakedArray(array: Array<string>): [number, number]
+/**
+ * This function is for tests that require a value allocated on the heap.
+ * Should NOT be used in production.
+ */
+export function createLeakedAttribute(message: string, attribute: Record<string, string>): [number, number]
+/**
+ * This function is for tests that require a value allocated on the heap.
+ * Should NOT be used in production.
+ */
+export function createLeakedBigint(bigInt: bigint): [number, number]
+/**
+ * This function is for tests that require a value allocated on the heap.
+ * Should NOT be used in production.
+ */
+export function createLeakedDouble(float: number): [number, number]
+export class AsyncClient {
+    static CreateConnection(connectionAddress: string): AsyncClient
+    get(key: string): Promise<string | null>
+    set(key: string, value: string): Promise<string | 'OK' | null>
+}
+/** A wrapper for a script object. As long as this object is alive, the script's code is saved in memory, and can be resent to the server. */
+export class Script {
+    /** Construct with the script's code. */
+    constructor(code: string)
+    /** Returns the hash of the script. */
+    getHash(): string
+}

node/rust-client/aarch64-unknown-linux-gnu/index.js

@@ -0,0 +1,308 @@
+/* tslint:disable */
+/* eslint-disable */
+/* prettier-ignore */
+
+/* auto-generated by NAPI-RS */
+
+const { existsSync, readFileSync } = require('fs')
+const { join } = require('path')
+
+const { platform, arch } = process
+
+let nativeBinding = null
+let localFileExisted = false
+let loadError = null
+
+function isMusl() {
+    // For Node 10
+    if (!process.report || typeof process.report.getReport !== 'function') {
+        try {
+            const lddPath = require('child_process').execSync('which ldd').toString().trim()
+            return readFileSync(lddPath, 'utf8').includes('musl')
+        } catch (e) {
+            return true
+        }
+    } else {
+        const { glibcVersionRuntime } = process.report.getReport().header
+        return !glibcVersionRuntime
+    }
+}
+
+switch (platform) {
+    case 'android':
+        switch (arch) {
+            case 'arm64':
+                localFileExisted = existsSync(join(__dirname, 'glide-rs.android-arm64.node'))
+                try {
+                    if (localFileExisted) {
+                        nativeBinding = require('./glide-rs.android-arm64.node')
+                    } else {
+                        nativeBinding = require('glide-rs-android-arm64')
+                    }
+                } catch (e) {
+                    loadError = e
+                }
+                break
+            case 'arm':
+                localFileExisted = existsSync(join(__dirname, 'glide-rs.android-arm-eabi.node'))
+                try {
+                    if (localFileExisted) {
+                        nativeBinding = require('./glide-rs.android-arm-eabi.node')
+                    } else {
+                        nativeBinding = require('glide-rs-android-arm-eabi')
+                    }
+                } catch (e) {
+                    loadError = e
+                }
+                break
+            default:
+                throw new Error(`Unsupported architecture on Android ${arch}`)
+        }
+        break
+    case 'win32':
+        switch (arch) {
+            case 'x64':
+                localFileExisted = existsSync(join(__dirname, 'glide-rs.win32-x64-msvc.node'))
+                try {
+                    if (localFileExisted) {
+                        nativeBinding = require('./glide-rs.win32-x64-msvc.node')
+                    } else {
+                        nativeBinding = require('glide-rs-win32-x64-msvc')
+                    }
+                } catch (e) {
+                    loadError = e
+                }
+                break
+            case 'ia32':
+                localFileExisted = existsSync(join(__dirname, 'glide-rs.win32-ia32-msvc.node'))
+                try {
+                    if (localFileExisted) {
+                        nativeBinding = require('./glide-rs.win32-ia32-msvc.node')
+                    } else {
+                        nativeBinding = require('glide-rs-win32-ia32-msvc')
+                    }
+                } catch (e) {
+                    loadError = e
+                }
+                break
+            case 'arm64':
+                localFileExisted = existsSync(join(__dirname, 'glide-rs.win32-arm64-msvc.node'))
+                try {
+                    if (localFileExisted) {
+                        nativeBinding = require('./glide-rs.win32-arm64-msvc.node')
+                    } else {
+                        nativeBinding = require('glide-rs-win32-arm64-msvc')
+                    }
+                } catch (e) {
+                    loadError = e
+                }
+                break
+            default:
+                throw new Error(`Unsupported architecture on Windows: ${arch}`)
+        }
+        break
+    case 'darwin':
+        localFileExisted = existsSync(join(__dirname, 'glide-rs.darwin-universal.node'))
+        try {
+            if (localFileExisted) {
+                nativeBinding = require('./glide-rs.darwin-universal.node')
+            } else {
+                nativeBinding = require('glide-rs-darwin-universal')
+            }
+            break
+        } catch {}
+        switch (arch) {
+            case 'x64':
+                localFileExisted = existsSync(join(__dirname, 'glide-rs.darwin-x64.node'))
+                try {
+                    if (localFileExisted) {
+                        nativeBinding = require('./glide-rs.darwin-x64.node')
+                    } else {
+                        nativeBinding = require('glide-rs-darwin-x64')
+                    }
+                } catch (e) {
+                    loadError = e
+                }
+                break
+            case 'arm64':
+                localFileExisted = existsSync(join(__dirname, 'glide-rs.darwin-arm64.node'))
+                try {
+                    if (localFileExisted) {
+                        nativeBinding = require('./glide-rs.darwin-arm64.node')
+                    } else {
+                        nativeBinding = require('glide-rs-darwin-arm64')
+                    }
+                } catch (e) {
+                    loadError = e
+                }
+                break
+            default:
+                throw new Error(`Unsupported architecture on macOS: ${arch}`)
+        }
+        break
+    case 'freebsd':
+        if (arch !== 'x64') {
+            throw new Error(`Unsupported architecture on FreeBSD: ${arch}`)
+        }
+        localFileExisted = existsSync(join(__dirname, 'glide-rs.freebsd-x64.node'))
+        try {
+            if (localFileExisted) {
+                nativeBinding = require('./glide-rs.freebsd-x64.node')
+            } else {
+                nativeBinding = require('glide-rs-freebsd-x64')
+            }
+        } catch (e) {
+            loadError = e
+        }
+        break
+    case 'linux':
+        switch (arch) {
+            case 'x64':
+                if (isMusl()) {
+                    localFileExisted = existsSync(join(__dirname, 'glide-rs.linux-x64-musl.node'))
+                    try {
+                        if (localFileExisted) {
+                            nativeBinding = require('./glide-rs.linux-x64-musl.node')
+                        } else {
+                            nativeBinding = require('glide-rs-linux-x64-musl')
+                        }
+                    } catch (e) {
+                        loadError = e
+                    }
+                } else {
+                    localFileExisted = existsSync(join(__dirname, 'glide-rs.linux-x64-gnu.node'))
+                    try {
+                        if (localFileExisted) {
+                            nativeBinding = require('./glide-rs.linux-x64-gnu.node')
+                        } else {
+                            nativeBinding = require('glide-rs-linux-x64-gnu')
+                        }
+                    } catch (e) {
+                        loadError = e
+                    }
+                }
+                break
+            case 'arm64':
+                if (isMusl()) {
+                    localFileExisted = existsSync(join(__dirname, 'glide-rs.linux-arm64-musl.node'))
+                    try {
+                        if (localFileExisted) {
+                            nativeBinding = require('./glide-rs.linux-arm64-musl.node')
+                        } else {
+                            nativeBinding = require('glide-rs-linux-arm64-musl')
+                        }
+                    } catch (e) {
+                        loadError = e
+                    }
+                } else {
+                    localFileExisted = existsSync(join(__dirname, 'glide-rs.linux-arm64-gnu.node'))
+                    try {
+                        if (localFileExisted) {
+                            nativeBinding = require('./glide-rs.linux-arm64-gnu.node')
+                        } else {
+                            nativeBinding = require('glide-rs-linux-arm64-gnu')
+                        }
+                    } catch (e) {
+                        loadError = e
+                    }
+                }
+                break
+            case 'arm':
+                localFileExisted = existsSync(join(__dirname, 'glide-rs.linux-arm-gnueabihf.node'))
+                try {
+                    if (localFileExisted) {
+                        nativeBinding = require('./glide-rs.linux-arm-gnueabihf.node')
+                    } else {
+                        nativeBinding = require('glide-rs-linux-arm-gnueabihf')
+                    }
+                } catch (e) {
+                    loadError = e
+                }
+                break
+            case 'riscv64':
+                if (isMusl()) {
+                    localFileExisted = existsSync(join(__dirname, 'glide-rs.linux-riscv64-musl.node'))
+                    try {
+                        if (localFileExisted) {
+                            nativeBinding = require('./glide-rs.linux-riscv64-musl.node')
+                        } else {
+                            nativeBinding = require('glide-rs-linux-riscv64-musl')
+                        }
+                    } catch (e) {
+                        loadError = e
+                    }
+                } else {
+                    localFileExisted = existsSync(join(__dirname, 'glide-rs.linux-riscv64-gnu.node'))
+                    try {
+                        if (localFileExisted) {
+                            nativeBinding = require('./glide-rs.linux-riscv64-gnu.node')
+                        } else {
+                            nativeBinding = require('glide-rs-linux-riscv64-gnu')
+                        }
+                    } catch (e) {
+                        loadError = e
+                    }
+                }
+                break
+            case 's390x':
+                localFileExisted = existsSync(join(__dirname, 'glide-rs.linux-s390x-gnu.node'))
+                try {
+                    if (localFileExisted) {
+                        nativeBinding = require('./glide-rs.linux-s390x-gnu.node')
+                    } else {
+                        nativeBinding = require('glide-rs-linux-s390x-gnu')
+                    }
+                } catch (e) {
+                    loadError = e
+                }
+                break
+            default:
+                throw new Error(`Unsupported architecture on Linux: ${arch}`)
+        }
+        break
+    default:
+        throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`)
+}
+
+if (!nativeBinding) {
+    if (loadError) {
+        throw loadError
+    }
+    throw new Error(`Failed to load native binding`)
+}
+
+const {
+    Level,
+    MAX_REQUEST_ARGS_LEN,
+    DEFAULT_TIMEOUT_IN_MILLISECONDS,
+    AsyncClient,
+    StartSocketConnection,
+    log,
+    InitInternalLogger,
+    valueFromSplitPointer,
+    createLeakedString,
+    createLeakedStringVec,
+    createLeakedMap,
+    createLeakedArray,
+    createLeakedAttribute,
+    createLeakedBigint,
+    createLeakedDouble,
+    Script,
+} = nativeBinding
+
+module.exports.Level = Level
+module.exports.MAX_REQUEST_ARGS_LEN = MAX_REQUEST_ARGS_LEN
+module.exports.DEFAULT_TIMEOUT_IN_MILLISECONDS = DEFAULT_TIMEOUT_IN_MILLISECONDS
+module.exports.AsyncClient = AsyncClient
+module.exports.StartSocketConnection = StartSocketConnection
+module.exports.log = log
+module.exports.InitInternalLogger = InitInternalLogger
+module.exports.valueFromSplitPointer = valueFromSplitPointer
+module.exports.createLeakedString = createLeakedString
+module.exports.createLeakedStringVec = createLeakedStringVec
+module.exports.createLeakedMap = createLeakedMap
+module.exports.createLeakedArray = createLeakedArray
+module.exports.createLeakedAttribute = createLeakedAttribute
+module.exports.createLeakedBigint = createLeakedBigint
+module.exports.createLeakedDouble = createLeakedDouble
+module.exports.Script = Script

node/tests/RedisClusterClient.test.ts

@@ -32,7 +32,7 @@ type Context = {
     client: RedisClusterClient;
 };
 
-const TIMEOUT = 10000;
+const TIMEOUT = 50000;
 
 describe("RedisClusterClient", () => {
     let testsFailed = 0;