Spanner go shared core write apis

[sinhasubham]

prototype: do not merge

[gemini-code-assist]

Code Review

This pull request introduces a prototype native Go shared core for the Node Spanner client, routing single-use read-only SQL queries and write/mutation APIs through a Go shared library via an N-API addon to optimize performance. Feedback on the implementation highlights several critical issues, including a type mismatch risk in C++ where safe integers are incorrectly encoded as INT64 instead of FLOAT64, an infinite retry loop on gRPC stream failures, potential alignment panics on 32-bit platforms with 64-bit atomic operations, memory leaks in the N-API thread-safe function calls, and connection leaks during gRPC pool initialization.

[gemini-code-assist]

Plain JS numbers are always encoded as FLOAT64 (numberValue) in @google-cloud/spanner, and only Spanner.Int wrappers are encoded as INT64. Encoding safe integers as INT64 strings by default will cause type mismatch errors on real Spanner databases when writing integer values to FLOAT64 columns.

            if (!std::isfinite(d)) {
                const char* s = std::isnan(d) ? "NaN" : (d > 0 ? "Infinity" : "-Infinity");
                size_t len = strlen(s);
                char* dst = arena.alloc(len + 1);
                memcpy(dst, s, len + 1);
                cell->kind = CELL_KIND_STRING;
                cell->str_val = dst;
                cell->str_len = static_cast<uint32_t>(len);
                cell->type_code = 3; // FLOAT64
            } else {
                cell->kind = CELL_KIND_NUMBER;
                cell->number_val = d;
                cell->type_code = 3; // FLOAT64
            }
            return;

[gemini-code-assist]

If the gRPC stream fails with Unavailable or Internal errors, this loop retries infinitely without any maximum attempt limit. This can cause tight infinite loops and CPU exhaustion if the database or network is down. Limit the number of retries.

Suggested change

	if (st.Code() == codes.Unavailable || st.Code() == codes.Internal) && len(lastResumeToken) > 0 {
	continue // Retry loop
	}
	if (st.Code() == codes.Unavailable || st.Code() == codes.Internal) && len(lastResumeToken) > 0 && attemptCount < 5 {
	continue // Retry loop
	}

[gemini-code-assist]

On 32-bit architectures, 64-bit atomic operations will panic if the variable is not 8-byte aligned. Using atomic.Uint64 instead of a raw uint64 guarantees proper alignment on all platforms.

Suggested change

	reqCounter uint64
	reqCounter atomic.Uint64

[gemini-code-assist]

Update the atomic increment to use the atomic.Uint64 API to prevent alignment panics on 32-bit platforms.

Suggested change

	idx := atomic.AddUint64(&c.reqCounter, 1) % count
	idx := c.reqCounter.Add(1) % count

[gemini-code-assist]

If napi_call_threadsafe_function fails (e.g., if the thread-safe function is closing or closed), the allocated batch is leaked. Check the return value and free the batch on failure.

    if (napi_call_threadsafe_function(ctx->tsfn, batch, napi_tsfn_nonblocking) != napi_ok) {
        if (batch) {
            if (batch->cells) free(batch->cells);
            if (batch->string_arena) free(batch->string_arena);
            if (batch->json_rows) free(batch->json_rows);
            if (batch->server_timing) free(batch->server_timing);
            if (batch->error_msg) free(batch->error_msg);
            if (batch->metadata_pb) free(batch->metadata_pb);
            free(batch);
        }
    }

[gemini-code-assist]

If napi_call_threadsafe_function fails, the allocated resp is leaked. Check the return value and free the response on failure.

    if (napi_call_threadsafe_function(ctx->tsfn, resp, napi_tsfn_nonblocking) != napi_ok) {
        if (resp) {
            if (resp->resp_pb) free(resp->resp_pb);
            if (resp->tx_pb) free(resp->tx_pb);
            if (resp->error_msg) free(resp->error_msg);
            if (resp->retry_info_pb) free(resp->retry_info_pb);
            free(resp);
        }
    }

[gemini-code-assist]

If any connection dial fails during the pool initialization loop, the successfully opened connections before the failure are leaked. Ensure they are closed before returning the error.

Suggested change

	for i := 0; i < limit; i++ {
	conn, err := grpc.DialContext(ctx, endpoint, dialOpts...)
	if err != nil {
	cancel()
	return nil, fmt.Errorf("failed to connect to Spanner endpoint %s: %w", endpoint, err)
	}
	conns[i] = conn
	conns := make([]*grpc.ClientConn, limit)
	for i := 0; i < limit; i++ {
	conn, err := grpc.DialContext(ctx, endpoint, dialOpts...)
	if err != nil {
	cancel()
	for j := 0; j < i; j++ {
	_ = conns[j].Close()
	}
	return nil, fmt.Errorf("failed to connect to Spanner endpoint %s: %w", endpoint, err)
	}
	conns[i] = conn
	}