napi metadata changes

surbhigarg92 · surbhigarg92 · commit 8c83c0b78042 · 2026-04-10T16:48:27.000+05:30
diff --git a/spannerlib/wrappers/spannerlib-nodejs-poc/napi/binding.gyp b/spannerlib/wrappers/spannerlib-nodejs-poc/napi/binding.gyp
@@ -39,10 +39,16 @@
         }],
         ['OS=="linux"', {
           'ldflags': [
-            '-Wl,-rpath,\'$$ORIGIN/../../../shared\''
+            '-Wl,-rpath,$$ORIGIN'
           ],
           'libraries': [
             '<(module_root_dir)/../../../shared/libspanner.so'
+          ],
+          'copies': [
+            {
+                'destination': '<(PRODUCT_DIR)',
+                'files': [ '<(module_root_dir)/../../../shared/libspanner.so' ]
+            }
           ]
         }]
       ]
diff --git a/spannerlib/wrappers/spannerlib-nodejs-poc/napi/package.json b/spannerlib/wrappers/spannerlib-nodejs-poc/napi/package.json
@@ -6,7 +6,8 @@
     "node": ">=20.0.0"
   },
   "scripts": {
-    "build": "node-gyp rebuild && install_name_tool -change libspanner.so @loader_path/libspanner.so ./build/Release/spanner_napi.node",
+    "build": "node-gyp rebuild",
+    "postbuild": "node -e \"if (process.platform === 'darwin') require('child_process').execSync('install_name_tool -change libspanner.so @loader_path/libspanner.so ./build/Release/spanner_napi.node')\"",
     "test": "node test.js",
     "setup": "node setup_db.js"
   },
diff --git a/spannerlib/wrappers/spannerlib-nodejs-poc/napi/src/cpp/addon.cc b/spannerlib/wrappers/spannerlib-nodejs-poc/napi/src/cpp/addon.cc
@@ -247,6 +247,49 @@ Napi::Value NextWrapper(const Napi::CallbackInfo& info) {
     return env.Undefined();
 }
 
+//
+// Worker 7: Metadata asynchronously
+//
+class MetadataWorker : public Napi::AsyncWorker {
+public:
+    MetadataWorker(Napi::Function& callback, int64_t poolId, int64_t connId, int64_t rowsId)
+        : AsyncWorker(callback), poolId_(poolId), connId_(connId), rowsId_(rowsId), result_({0, 0, 0, 0, nullptr}) {}
+
+    void Execute() override {
+        result_ = ::Metadata(poolId_, connId_, rowsId_);
+    }
+
+    void OnOK() override {
+        Napi::Env env = Env();
+        Napi::Object obj = Napi::Object::New(env);
+        obj.Set("r0", Napi::Number::New(env, result_.r0));
+        obj.Set("r1", Napi::Number::New(env, result_.r1));
+        obj.Set("r2", Napi::Number::New(env, result_.r2));
+        obj.Set("r3", Napi::Number::New(env, result_.r3));
+        if (result_.r4 != nullptr && result_.r3 > 0) {
+            obj.Set("r4", Napi::Buffer<uint8_t>::Copy(env, (uint8_t*)result_.r4, result_.r3));
+        } else {
+            obj.Set("r4", env.Null());
+        }
+        Callback().Call({env.Null(), obj});
+    }
+private:
+    int64_t poolId_, connId_, rowsId_;
+    Metadata_return result_;
+};
+
+Napi::Value MetadataWrapper(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    int64_t pid = info[0].As<Napi::Number>().Int64Value();
+    int64_t cid = info[1].As<Napi::Number>().Int64Value();
+    int64_t rid = info[2].As<Napi::Number>().Int64Value();
+    Napi::Function cb = info[3].As<Napi::Function>();
+    
+    MetadataWorker* worker = new MetadataWorker(cb, pid, cid, rid);
+    worker->Queue();
+    return env.Undefined();
+}
+
 // Memory Release (Synchronous as it is just freeing RAM via GC)
 Napi::Value NativeRelease(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
@@ -288,6 +331,7 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
     exports.Set("CloseRows", Napi::Function::New(env, CloseRowsWrapper));
     exports.Set("Release", Napi::Function::New(env, NativeRelease));
     
+    exports.Set("Metadata", Napi::Function::New(env, MetadataWrapper));
     return exports;
 }
 
diff --git a/spannerlib/wrappers/spannerlib-nodejs-poc/napi/src/ffi/utils.js b/spannerlib/wrappers/spannerlib-nodejs-poc/napi/src/ffi/utils.js
@@ -1,5 +1,8 @@
 const addon = require('../../build/Release/spanner_napi.node');
 
+const ENCODING_JSON = 0;
+const ENCODING_PROTOBUF = 1;
+
 /**
  * Normalizes C++ responses to look structurally identical to what Koffi did.
  * Koffi returned: { r0: int, r1: int, r2: int, r3: int, r4: pointer/buffer }
@@ -43,6 +46,8 @@ function invokeAsync(funcName, constructor1, constructor2, ...args) {
 const Release = addon.Release;
 
 module.exports = {
+    ENCODING_JSON,
+    ENCODING_PROTOBUF,
     invokeAsync,
     Release
 };
diff --git a/spannerlib/wrappers/spannerlib-nodejs-poc/napi/src/lib/connection.js b/spannerlib/wrappers/spannerlib-nodejs-poc/napi/src/lib/connection.js
@@ -56,17 +56,37 @@ class Connection {
         const ExecuteSqlRequestProto = google.spanner.v1.ExecuteSqlRequest;
         const serializedPb = ExecuteSqlRequestProto.encode(requestObj).finish();
 
-        // 2. Transmit the standard protobuf binary buffer over CGO FFI seamlessly
-        const handled = await invokeAsync(
-            Execute,
-            null, // Rows gets constructed afterward
+        // 1. Execute the SQL to get a Rows identifier
+        const rowsResult = await invokeAsync(
+            "Execute",
+            null,
             null,
             this.pool.oid,
             this.oid,
             serializedPb
         );
+        const rowsId = rowsResult.objectId;
 
-        return new Rows(this, handled.objectId);
+        // 2. Fetch the metadata to get column names
+        const metadataResult = await invokeAsync(
+            "Metadata",
+            null,
+            null,
+            this.pool.oid,
+            this.oid,
+            rowsId
+        );
+        
+        // 3. Decode the metadata protobuf
+        const ResultSetMetadataProto = google.spanner.v1.ResultSetMetadata;
+        const metadata = ResultSetMetadataProto.decode(metadataResult.protobufBytes);
+        const columnInfo = metadata.rowType.fields.map(field => ({
+            name: field.name,
+            typeCode: field.type.code
+        }));
+        
+        // 4. Return a new Rows object, now equipped with the column info
+        return new Rows(this, rowsId, columnInfo);
     }
 
     /**
diff --git a/spannerlib/wrappers/spannerlib-nodejs-poc/napi/src/lib/rows.js b/spannerlib/wrappers/spannerlib-nodejs-poc/napi/src/lib/rows.js
@@ -1,70 +1,96 @@
-const { CloseRows, Next } = require('../ffi/bindings.js');
-const { invokeAsync } = require('../ffi/utils.js');
+const { invokeAsync, ENCODING_PROTOBUF } = require('../ffi/utils.js');
 const { spannerLib } = require('./spannerlib.js');
 const { google } = require('@google-cloud/spanner/build/protos/protos.js');
+const ListValue = google.protobuf.ListValue;
+
+/**
+ * Parses a binary `ListValue` protobuf message into a key-value row object.
+ * @param {Buffer} buffer The binary buffer from the Go library.
+ * @param {Array<{name: string, typeCode: number}>} columnInfo An array of objects with column names and types.
+ * @returns {object|null}
+ */
+function parseRowToObject(buffer, columnInfo) {
+    if (!buffer || buffer.length === 0) {
+        return null; // End of result set
+    }
+
+    const listValue = ListValue.decode(buffer);
+    const rowObject = {};
+    const values = listValue.values;
+
+    columnInfo.forEach((column, index) => {
+        const value = values[index];
+        const columnName = column.name;
+        let parsedValue;
+
+        // The decoded `value` object has a 'kind' oneof field.
+        // We check which property is set to get the primitive value.
+        switch (value.kind) {
+            case 'nullValue':
+                parsedValue = null;
+                break;
+            case 'numberValue':
+                parsedValue = value.numberValue;
+                break;
+            case 'stringValue':
+                parsedValue = value.stringValue;
+                break;
+            case 'boolValue':
+                parsedValue = value.boolValue;
+                break;
+            default:
+                parsedValue = undefined;
+        }
+        rowObject[columnName] = parsedValue;
+    });
+
+    return rowObject;
+}
 
 class Rows {
     /**
-     * @param {import('./connection.js').Connection} conn 
-     * @param {Number} objectId - The OID identifying these rows inside the Go Driver
+     * @param {import('./connection.js').Connection} connection
+     * @param {Number} oid
+     * @param {Array<{name: string, typeCode: number}>} columnInfo
      */
-    constructor(conn, objectId) {
-        this.conn = conn;
-
-        /**
-         * The Object ID (OID). 
-         * Used to execute operations like `.next()` against THIS specific ResultSet inside Go.
-         * @type {Number|null}
-         */
-        this.oid = objectId;
-
+    constructor(connection, oid, columnInfo) {
+        this.connection = connection;
+        this.oid = oid;
+        this.pinnerId = null;
         this.closed = false;
-        
-        // FinalizationRegistry could optionally be mapped to this via 
-        // spannerLib.register(this, pinnerId_from_execute)
-        // For the POC, we won't fully map the Rows Pinner unless needed
-        // by the Next() function iterator.
+        this.columnInfo = columnInfo; // Store column names and types
     }
 
     /**
-     * Iterates to the next result chunk.
-     * In a full implementation, it would call `Next(poolId, connId, rowsId, ...)` natively.
+     * Fetches the next row from the result set.
+     * @returns {Promise<object|null>} A promise that resolves to a row object, or null if there are no more rows.
      */
     async next() {
-        if (this.closed) throw new Error("Rows object is already closed");
-
-        // Go Signature: Next(poolId, connId, rowsId, numRows, encodeRowOption) 
-        // We pass 1 for numRows, and 0 for encodeRowOption as per POC defaults
-        const handled = await invokeAsync(Next, null, null, this.conn.pool.oid, this.conn.oid, this.oid, 1, 0);
-
-        // Handle EOF case (The chunk buffer is perfectly empty or contains no message)
-        if (!handled.protobufBytes || handled.protobufBytes.length === 0) {
-            return null; // Signals end of rows to the caller
-        }
-
-        // The returned message contains a google.protobuf.ListValue according to the spec!
-        // We natively unpack those bytes matching standard Protobuf conventions.
-        const listValueProto = google.protobuf.ListValue;
-        const decodedList = listValueProto.decode(handled.protobufBytes);
+        if (this.closed) throw new Error("Rows are already closed");
 
-        // This converts the complex generic Protobuf ListValue deeply into native Javascript!
-        const jsonRecord = listValueProto.toObject(decodedList, {
-            longs: String, // Ensure Int64 types from Spanner decode as Strings instead of mangled JS doubles
-            enums: String,
-            bytes: String,
-        });
+        const handled = await invokeAsync(
+            "Next",
+            null,
+            null,
+            this.connection.pool.oid,
+            this.connection.oid,
+            this.oid,
+            1, // Fetch one row at a time
+            ENCODING_PROTOBUF
+        );
 
-        return jsonRecord.values || [];
+        // The result for `Next` is a binary `ListValue` protobuf message.
+        return parseRowToObject(handled.protobufBytes, this.columnInfo);
     }
 
-    /**
-     * Closes the rows object safely, waiting on the network.
-     */
     async close() {
         if (!this.closed) {
             this.closed = true;
-            // Native FFI execution in the background
-            await invokeAsync(CloseRows, null, spannerLib, this.conn.pool.oid, this.conn.oid, this.oid);
+            try {
+                await invokeAsync("CloseRows", this, spannerLib, this.connection.pool.oid, this.connection.oid, this.oid);
+            } finally {
+                spannerLib.unregister(this, this.pinnerId);
+            }
         }
     }
 }
diff --git a/spannerlib/wrappers/spannerlib-nodejs-poc/napi/test.js b/spannerlib/wrappers/spannerlib-nodejs-poc/napi/test.js
@@ -34,12 +34,19 @@ async function runTest() {
         rows = await connection.executeSql(sqlQuery);
         console.log(`Executed SQL successfully in ${(performance.now() - startTime).toFixed(3)}ms (Rows OID: ${rows.oid})`);
 
-        console.log("\n[JS-App] 4. Fetching ResultSet Native Types (Int, String, Float, Bool)...");
-        let nextRow;
-        while ((nextRow = await rows.next()) !== null) {
-            // nextRow is an array of Value protobuf objects (Google Protobuf Structs)
-            console.log(" - Fetched native row chunk ->");
-            console.log("    " + JSON.stringify(nextRow));
+        console.log("\n[JS-App] 4. Fetching ResultSet as Objects...");
+        let row;
+        const results = [];
+        while ((row = await rows.next()) !== null) {
+            results.push(row);
+        }
+        
+        console.log(" - Fetched rows ->");
+        console.log(JSON.stringify(results, null, 2));
+
+        // Example of accessing a property on the first row
+        if (results.length > 0) {
+            console.log(`\nExample access: results[0].FirstName is "${results[0].FirstName}"`);
         }
 
     } catch (err) {
