@themainstack/communication 1.1.1 → 1.1.2

package/dist/grpc/struct-utils.js

@@ -11,10 +11,22 @@ exports.structToJson = structToJson;
  * Convert a plain JS object/value to google.protobuf.Value
  */
 function jsonToValue(val) {
-    if (val === null || val === undefined) {
+    // 1. Handle toJSON (covers Date and custom objects)
+    // Note: JSON.stringify calls toJSON() first.
+    if (val && typeof val.toJSON === 'function') {
+        val = val.toJSON();
+    }
+    // 2. Handle undefined/null
+    // undefined in Array becomes null. undefined passed directly becomes nullValue.
+    if (val === undefined || val === null) {
         return { nullValue: 0 };
     }
+    // 3. Primitives
     if (typeof val === 'number') {
+        // Handle infinity/NaN? Protobuf uses strings/special doubles, but standard jsonToValue usually
+        // expects finite numbers. JSON.stringify converts Infinity/NaN to null.
+        if (!Number.isFinite(val))
+            return { nullValue: 0 };
         return { numberValue: val };
     }
     if (typeof val === 'string') {
@@ -23,13 +35,17 @@ function jsonToValue(val) {
     if (typeof val === 'boolean') {
         return { boolValue: val };
     }
+    // 4. Arrays
     if (Array.isArray(val)) {
         return { listValue: { values: val.map(jsonToValue) } };
     }
+    // 5. Objects (Struct)
     if (typeof val === 'object') {
         return { structValue: jsonToStruct(val) };
     }
-    throw new Error(`Unsupported type for Struct conversion: ${typeof val}`);
+    // Functions/Symbols in array -> null (JSON behavior)
+    // But usually we throw or ignore. JSON.stringify([function(){}]) -> [null]
+    return { nullValue: 0 };
 }
 /**
  * Convert a plain JS object to google.protobuf.Struct
@@ -37,8 +53,19 @@ function jsonToValue(val) {
 function jsonToStruct(json) {
     const fields = {};
     for (const k in json) {
+        // Only process own enumerable properties (standard JSON behavior usually)
         if (Object.prototype.hasOwnProperty.call(json, k)) {
-            fields[k] = jsonToValue(json[k]);
+            let v = json[k];
+            // 1. Resolve toJSON
+            if (v && typeof v.toJSON === 'function') {
+                v = v.toJSON();
+            }
+            // 2. Skip properties that are undefined, functions, or symbols (standard JSON behavior)
+            if (v === undefined || typeof v === 'function' || typeof v === 'symbol') {
+                continue;
+            }
+            // 3. Convert remainder
+            fields[k] = jsonToValue(v);
         }
     }
     return { fields };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@themainstack/communication",
-    "version": "1.1.1",
+    "version": "1.1.2",
     "private": false,
     "description": "Unified gRPC framework for inter-service communication - auto-generates protos, creates servers, and provides type-safe clients",
     "main": "dist/index.js",

package/src/grpc/struct-utils.ts

@@ -6,10 +6,23 @@
  * Convert a plain JS object/value to google.protobuf.Value
  */
 export function jsonToValue(val: any): any {
-    if (val === null || val === undefined) {
+    // 1. Handle toJSON (covers Date and custom objects)
+    // Note: JSON.stringify calls toJSON() first.
+    if (val && typeof val.toJSON === 'function') {
+        val = val.toJSON();
+    }
+
+    // 2. Handle undefined/null
+    // undefined in Array becomes null. undefined passed directly becomes nullValue.
+    if (val === undefined || val === null) {
         return { nullValue: 0 };
     }
+
+    // 3. Primitives
     if (typeof val === 'number') {
+        // Handle infinity/NaN? Protobuf uses strings/special doubles, but standard jsonToValue usually
+        // expects finite numbers. JSON.stringify converts Infinity/NaN to null.
+        if (!Number.isFinite(val)) return { nullValue: 0 };
         return { numberValue: val };
     }
     if (typeof val === 'string') {
@@ -18,13 +31,20 @@ export function jsonToValue(val: any): any {
     if (typeof val === 'boolean') {
         return { boolValue: val };
     }
+
+    // 4. Arrays
     if (Array.isArray(val)) {
         return { listValue: { values: val.map(jsonToValue) } };
     }
+
+    // 5. Objects (Struct)
     if (typeof val === 'object') {
         return { structValue: jsonToStruct(val) };
     }
-    throw new Error(`Unsupported type for Struct conversion: ${typeof val}`);
+
+    // Functions/Symbols in array -> null (JSON behavior)
+    // But usually we throw or ignore. JSON.stringify([function(){}]) -> [null]
+    return { nullValue: 0 };
 }
 
 /**
@@ -33,8 +53,22 @@ export function jsonToValue(val: any): any {
 export function jsonToStruct(json: any): any {
     const fields: Record<string, any> = {};
     for (const k in json) {
+        // Only process own enumerable properties (standard JSON behavior usually)
         if (Object.prototype.hasOwnProperty.call(json, k)) {
-            fields[k] = jsonToValue(json[k]);
+            let v = json[k];
+
+            // 1. Resolve toJSON
+            if (v && typeof v.toJSON === 'function') {
+                v = v.toJSON();
+            }
+
+            // 2. Skip properties that are undefined, functions, or symbols (standard JSON behavior)
+            if (v === undefined || typeof v === 'function' || typeof v === 'symbol') {
+                continue;
+            }
+
+            // 3. Convert remainder
+            fields[k] = jsonToValue(v);
         }
     }
     return { fields };

package/tests/fixtures/regression.proto

@@ -0,0 +1,18 @@
+syntax = "proto3";
+
+package regression.v1;
+
+import "google/protobuf/struct.proto";
+
+// RegressionService - Auto-generated gRPC service
+service RegressionService {
+  rpc Echo (EchoRequest) returns (EchoResponse) {}
+}
+
+message EchoResponse {
+  google.protobuf.Struct result = 1;
+}
+
+message EchoRequest {
+  google.protobuf.Struct data = 1;
+}

package/tests/struct-edge-cases.spec.ts

@@ -0,0 +1,47 @@
+import { describe, it, expect } from 'vitest';
+import { jsonToStruct, structToJson } from '../src/grpc/struct-utils';
+
+describe('struct-utils edge cases', () => {
+    it('should handle Dates by converting to ISO string (like JSON.stringify)', () => {
+        const date = new Date('2023-01-01T00:00:00.000Z');
+        const input = { createdAt: date };
+
+        // JSON.stringify behavior:
+        // {"createdAt":"2023-01-01T00:00:00.000Z"}
+
+        const struct = jsonToStruct(input);
+        const output = structToJson(struct);
+
+        expect(output.createdAt).toBe(date.toISOString());
+    });
+
+    it('should ignore undefined fields (like JSON.stringify)', () => {
+        const input = { defined: true, missing: undefined };
+
+        // JSON.stringify behavior:
+        // {"defined":true}
+
+        const struct = jsonToStruct(input);
+        const output = structToJson(struct);
+
+        expect(output).toHaveProperty('defined');
+        expect(output).not.toHaveProperty('missing');
+    });
+
+    it('should support toJSON() method', () => {
+        const input = {
+            custom: {
+                val: 123,
+                toJSON() { return { val: 456 }; }
+            }
+        };
+
+        // JSON.stringify behavior:
+        // {"custom":{"val":456}}
+
+        const struct = jsonToStruct(input);
+        const output = structToJson(struct);
+
+        expect(output.custom.val).toBe(456);
+    });
+});

package/tests/struct-regression.spec.ts

@@ -0,0 +1,72 @@
+import { describe, it, expect } from 'vitest';
+import { GrpcServerFactory, GrpcClientFactory, AnyType } from '../src/index';
+import * as path from 'path';
+import * as fs from 'fs';
+
+describe('Struct Regression Integration', () => {
+    it('should transparently handle plain JSON including Dates across gRPC', async () => {
+        const PORT = 50058;
+        const PACKAGE_NAME = 'regression.v1';
+        const SERVICE_NAME = 'RegressionService';
+
+        // Define service using AnyType (which maps to Struct)
+        const handlers = [{
+            name: 'Echo',
+            handler: async (req: any) => {
+                // Return exactly what we received to verify server-side unwrapping
+                return { result: req.data };
+            },
+            requestSample: () => ({ data: AnyType }),
+            responseSample: () => ({ result: AnyType }),
+        }];
+
+        const mkDir = path.join(__dirname, 'fixtures');
+        if (!fs.existsSync(mkDir)) fs.mkdirSync(mkDir, { recursive: true });
+
+        // Start Server
+        const server = await GrpcServerFactory.createServer({
+            packageName: PACKAGE_NAME,
+            serviceName: SERVICE_NAME,
+            port: PORT,
+            protoOutputDir: mkDir,
+        }, handlers);
+        await server.start();
+
+        // Create Client
+        const client = GrpcClientFactory.createClient<any>({
+            packageName: PACKAGE_NAME,
+            serviceName: SERVICE_NAME,
+            protoPath: path.join(mkDir, 'regression.proto'),
+            url: `0.0.0.0:${PORT}`,
+        });
+
+        // Test Payload
+        const date = new Date('2024-01-01T12:00:00.000Z');
+        const payload = {
+            message: 'hello',
+            count: 42,
+            createdAt: date,
+            missing: undefined
+        };
+
+        try {
+            const response = await new Promise((resolve, reject) => {
+                client.Echo({ data: payload }, (err: any, res: any) => {
+                    if (err) reject(err);
+                    else resolve(res);
+                });
+            });
+
+            // Verify Client -> Server (Server unwrapped correctly) -> Client (Client unwrapped correctly)
+            const result = (response as any).result;
+
+            expect(result.message).toBe('hello');
+            expect(result.count).toBe(42);
+            expect(result.createdAt).toBe(date.toISOString()); // Date became string
+            expect(result).not.toHaveProperty('missing'); // undefined removed
+
+        } finally {
+            server.stop();
+        }
+    });
+});