@themainstack/communication 1.1.0 → 1.1.1

package/dist/grpc/client-factory.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GrpcClientFactory = void 0;
 const grpc = __importStar(require("@grpc/grpc-js"));
 const protoLoader = __importStar(require("@grpc/proto-loader"));
+const struct_utils_1 = require("./struct-utils");
 class GrpcClientFactory {
     static createClient(options) {
         const packageDefinition = protoLoader.loadSync(options.protoPath, {
@@ -67,7 +68,69 @@ class GrpcClientFactory {
             throw new Error(`Service '${options.serviceName}' not found in ${location}`);
         }
         const ServiceClient = serviceDef[options.serviceName];
-        return new ServiceClient(options.url, options.credentials || grpc.credentials.createInsecure(), options.channelOptions);
+        const client = new ServiceClient(options.url, options.credentials || grpc.credentials.createInsecure(), options.channelOptions);
+        // Wrap the client to intercept methods and handle Struct conversion automatically
+        const wrapper = new Proxy(client, {
+            get(target, prop) {
+                const value = target[prop];
+                // If accessing a method function, wrap it
+                if (typeof prop === 'string' && typeof value === 'function') {
+                    // Find the method definition in the proto package definition
+                    // packageDefinition uses flattened keys: 'package.Service.Method' or 'Service.Method' if in root
+                    const methodKey = packageName
+                        ? `${packageName}.${options.serviceName}`
+                        : options.serviceName;
+                    // We need to look up the method definition to get request type
+                    // The loaded packageDefinition is a flat map of FQN -> type definition
+                    // But we don't have easy link from method name to request FQN here without traversing.
+                    // Fortunately, ServiceClient.service (available on constructor) has the method definitions!
+                    const serviceDefinition = ServiceClient.service;
+                    const methodDef = serviceDefinition[prop];
+                    if (methodDef && !methodDef.requestStream && !methodDef.responseStream) {
+                        return (...args) => {
+                            const request = args[0];
+                            if (request && typeof request === 'object') {
+                                // Introspect and convert Struct fields
+                                const requestType = methodDef.requestType; // This contains the type definition structure
+                                if (requestType && requestType.format === 'Protocol Buffer 3 DescriptorProto') {
+                                    // With @grpc/grpc-js and proto-loader, type info is attached
+                                    // traverse fields to find google.protobuf.Struct
+                                    for (const field of requestType.type.field) {
+                                        if (field.typeName === 'google.protobuf.Struct' && request[field.name]) {
+                                            // Auto-convert JSON to Struct
+                                            request[field.name] = (0, struct_utils_1.jsonToStruct)(request[field.name]);
+                                        }
+                                    }
+                                }
+                            }
+                            // Intercept callback to unwrap Response Structs
+                            const originalCallback = typeof args[args.length - 1] === 'function'
+                                ? args[args.length - 1]
+                                : undefined;
+                            if (originalCallback) {
+                                args[args.length - 1] = (err, response) => {
+                                    if (response && typeof response === 'object') {
+                                        const responseType = methodDef.responseType;
+                                        if (responseType && responseType.format === 'Protocol Buffer 3 DescriptorProto') {
+                                            for (const field of responseType.type.field) {
+                                                if (field.typeName === 'google.protobuf.Struct' && response[field.name]) {
+                                                    // Auto-convert Struct -> JSON
+                                                    response[field.name] = (0, struct_utils_1.structToJson)(response[field.name]);
+                                                }
+                                            }
+                                        }
+                                    }
+                                    originalCallback(err, response);
+                                };
+                            }
+                            return value.apply(target, args);
+                        };
+                    }
+                }
+                return value;
+            }
+        });
+        return wrapper;
     }
 }
 exports.GrpcClientFactory = GrpcClientFactory;

package/dist/grpc/server-factory.js

@@ -39,6 +39,7 @@ const grpc = __importStar(require("@grpc/grpc-js"));
 const protoLoader = __importStar(require("@grpc/proto-loader"));
 const path = __importStar(require("path"));
 const proto_generator_1 = require("../proto-generator");
+const struct_utils_1 = require("./struct-utils");
 /**
  * GrpcServerFactory - Create and run gRPC servers easily
  *
@@ -123,7 +124,27 @@ class GrpcServerFactory {
             const methodName = handler.name.charAt(0).toLowerCase() + handler.name.slice(1);
             implementations[methodName] = async (call, callback) => {
                 try {
-                    const result = await handler.handler(call.request);
+                    let request = call.request;
+                    // Introspect Request for Struct fields and unwrap to JSON
+                    const methodDef = ServiceConstructor.service[handler.name];
+                    if (methodDef && methodDef.requestType && methodDef.requestType.format === 'Protocol Buffer 3 DescriptorProto') {
+                        for (const field of methodDef.requestType.type.field) {
+                            if (field.typeName === 'google.protobuf.Struct' && request[field.name]) {
+                                // Convert Struct -> JSON for the handler
+                                request[field.name] = (0, struct_utils_1.structToJson)(request[field.name]);
+                            }
+                        }
+                    }
+                    const result = await handler.handler(request);
+                    // Introspect Response for Struct fields and wrap JSON to Struct
+                    if (result && typeof result === 'object' && methodDef && methodDef.responseType && methodDef.responseType.format === 'Protocol Buffer 3 DescriptorProto') {
+                        for (const field of methodDef.responseType.type.field) {
+                            if (field.typeName === 'google.protobuf.Struct' && result[field.name]) {
+                                // Convert JSON -> Struct for the callback
+                                result[field.name] = (0, struct_utils_1.jsonToStruct)(result[field.name]);
+                            }
+                        }
+                    }
                     callback(null, result);
                 }
                 catch (error) {

package/dist/grpc/struct-utils.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Utilities for converting between JSON/JS Objects and google.protobuf.Struct
+ */
+/**
+ * Convert a plain JS object/value to google.protobuf.Value
+ */
+export declare function jsonToValue(val: any): any;
+/**
+ * Convert a plain JS object to google.protobuf.Struct
+ */
+export declare function jsonToStruct(json: any): any;
+/**
+ * Convert google.protobuf.Value to JS value
+ */
+export declare function valueToJson(val: any): any;
+/**
+ * Convert google.protobuf.Struct to plain JS object
+ */
+export declare function structToJson(struct: any): any;

package/dist/grpc/struct-utils.js

@@ -0,0 +1,81 @@
+"use strict";
+/**
+ * Utilities for converting between JSON/JS Objects and google.protobuf.Struct
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonToValue = jsonToValue;
+exports.jsonToStruct = jsonToStruct;
+exports.valueToJson = valueToJson;
+exports.structToJson = structToJson;
+/**
+ * Convert a plain JS object/value to google.protobuf.Value
+ */
+function jsonToValue(val) {
+    if (val === null || val === undefined) {
+        return { nullValue: 0 };
+    }
+    if (typeof val === 'number') {
+        return { numberValue: val };
+    }
+    if (typeof val === 'string') {
+        return { stringValue: val };
+    }
+    if (typeof val === 'boolean') {
+        return { boolValue: val };
+    }
+    if (Array.isArray(val)) {
+        return { listValue: { values: val.map(jsonToValue) } };
+    }
+    if (typeof val === 'object') {
+        return { structValue: jsonToStruct(val) };
+    }
+    throw new Error(`Unsupported type for Struct conversion: ${typeof val}`);
+}
+/**
+ * Convert a plain JS object to google.protobuf.Struct
+ */
+function jsonToStruct(json) {
+    const fields = {};
+    for (const k in json) {
+        if (Object.prototype.hasOwnProperty.call(json, k)) {
+            fields[k] = jsonToValue(json[k]);
+        }
+    }
+    return { fields };
+}
+/**
+ * Convert google.protobuf.Value to JS value
+ */
+function valueToJson(val) {
+    if (!val)
+        return null;
+    if ('nullValue' in val)
+        return null;
+    if ('numberValue' in val)
+        return val.numberValue;
+    if ('stringValue' in val)
+        return val.stringValue;
+    if ('boolValue' in val)
+        return val.boolValue;
+    if ('listValue' in val) {
+        return (val.listValue.values || []).map(valueToJson);
+    }
+    if ('structValue' in val) {
+        return structToJson(val.structValue);
+    }
+    // Fallback if 'kind' oneof logic is different in some implementations,
+    // but usually keys are explicit.
+    return null;
+}
+/**
+ * Convert google.protobuf.Struct to plain JS object
+ */
+function structToJson(struct) {
+    if (!struct || !struct.fields)
+        return {};
+    const json = {};
+    for (const k in struct.fields) {
+        json[k] = valueToJson(struct.fields[k]);
+    }
+    return json;
+}

package/dist/proto-generator/index.js

@@ -45,7 +45,7 @@ const path = __importStar(require("path"));
  * @example
  * requestSample: () => ({ id: '', data: AnyType })
  */
-exports.AnyType = Symbol('google.protobuf.Any');
+exports.AnyType = Symbol('google.protobuf.Struct');
 /**
  * Generate a complete .proto file from method definitions
  *
@@ -83,8 +83,8 @@ function generateProtoFromMethods(methods, options = {}) {
             let rule = undefined;
             const valueType = typeof value;
             // Check for AnyType marker symbol
-            if (enableAnyType && (value === exports.AnyType || (typeof value === 'symbol' && value.description === 'google.protobuf.Any'))) {
-                type = "google.protobuf.Any";
+            if (enableAnyType && (value === exports.AnyType || (typeof value === 'symbol' && value.description === 'google.protobuf.Any') || (typeof value === 'symbol' && value.description === 'google.protobuf.Struct'))) {
+                type = "google.protobuf.Struct";
                 usesAnyType = true;
             }
             else if (value === null || value === undefined) {
@@ -155,9 +155,9 @@ function generateProtoFromMethods(methods, options = {}) {
     if (packageName) {
         lines.push(`package ${packageName};`, '');
     }
-    // Add google.protobuf.Any import if needed
+    // Add google.protobuf.Struct import if needed
     if (usesAnyType) {
-        lines.push('import "google/protobuf/any.proto";', '');
+        lines.push('import "google/protobuf/struct.proto";', '');
     }
     // Service definition
     lines.push(`// ${serviceName} - Auto-generated gRPC service`);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@themainstack/communication",
-    "version": "1.1.0",
+    "version": "1.1.1",
     "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/client-factory.ts

@@ -1,6 +1,7 @@
 import * as grpc from '@grpc/grpc-js';
 import * as protoLoader from '@grpc/proto-loader';
 import { GrpcClientOptions } from './types';
+import { jsonToStruct, structToJson } from './struct-utils';
 
 export class GrpcClientFactory {
     static createClient<T extends grpc.Client>(options: GrpcClientOptions): T {
@@ -39,10 +40,82 @@ export class GrpcClientFactory {
 
         const ServiceClient = serviceDef[options.serviceName];
 
-        return new ServiceClient(
+        const client = new ServiceClient(
             options.url,
             options.credentials || grpc.credentials.createInsecure(),
             options.channelOptions
         ) as T;
+
+        // Wrap the client to intercept methods and handle Struct conversion automatically
+        const wrapper = new Proxy(client, {
+            get(target: any, prop: string | symbol) {
+                const value = target[prop];
+
+                // If accessing a method function, wrap it
+                if (typeof prop === 'string' && typeof value === 'function') {
+                    // Find the method definition in the proto package definition
+                    // packageDefinition uses flattened keys: 'package.Service.Method' or 'Service.Method' if in root
+                    const methodKey = packageName
+                        ? `${packageName}.${options.serviceName}`
+                        : options.serviceName;
+
+                    // We need to look up the method definition to get request type
+                    // The loaded packageDefinition is a flat map of FQN -> type definition
+                    // But we don't have easy link from method name to request FQN here without traversing.
+                    // Fortunately, ServiceClient.service (available on constructor) has the method definitions!
+
+                    const serviceDefinition = ServiceClient.service;
+                    const methodDef = serviceDefinition[prop];
+
+                    if (methodDef && !methodDef.requestStream && !methodDef.responseStream) {
+                        return (...args: any[]) => {
+                            const request = args[0];
+                            if (request && typeof request === 'object') {
+                                // Introspect and convert Struct fields
+                                const requestType = methodDef.requestType; // This contains the type definition structure
+                                if (requestType && requestType.format === 'Protocol Buffer 3 DescriptorProto') {
+                                    // With @grpc/grpc-js and proto-loader, type info is attached
+                                    // traverse fields to find google.protobuf.Struct
+                                    for (const field of requestType.type.field) {
+                                        if (field.typeName === 'google.protobuf.Struct' && request[field.name]) {
+                                            // Auto-convert JSON to Struct
+                                            request[field.name] = jsonToStruct(request[field.name]);
+                                        }
+                                    }
+                                }
+                            }
+
+                            // Intercept callback to unwrap Response Structs
+                            const originalCallback = typeof args[args.length - 1] === 'function'
+                                ? args[args.length - 1]
+                                : undefined;
+
+                            if (originalCallback) {
+                                args[args.length - 1] = (err: any, response: any) => {
+                                    if (response && typeof response === 'object') {
+                                        const responseType = methodDef.responseType;
+                                        if (responseType && responseType.format === 'Protocol Buffer 3 DescriptorProto') {
+                                            for (const field of responseType.type.field) {
+                                                if (field.typeName === 'google.protobuf.Struct' && response[field.name]) {
+                                                    // Auto-convert Struct -> JSON
+                                                    response[field.name] = structToJson(response[field.name]);
+                                                }
+                                            }
+                                        }
+                                    }
+                                    originalCallback(err, response);
+                                };
+                            }
+
+                            return value.apply(target, args);
+                        };
+                    }
+                }
+
+                return value;
+            }
+        });
+
+        return wrapper as T;
     }
 }

package/src/grpc/server-factory.ts

@@ -3,6 +3,7 @@ import * as protoLoader from '@grpc/proto-loader';
 import * as path from 'path';
 import * as fs from 'fs';
 import { generateProtoFromMethods, MethodDefinition } from '../proto-generator';
+import { jsonToStruct, structToJson } from './struct-utils';
 
 /**
  * Options for creating a gRPC server
@@ -148,7 +149,31 @@ export class GrpcServerFactory {
                 callback: grpc.sendUnaryData<any>
             ) => {
                 try {
-                    const result = await handler.handler(call.request);
+                    let request = call.request;
+
+                    // Introspect Request for Struct fields and unwrap to JSON
+                    const methodDef = ServiceConstructor.service[handler.name];
+                    if (methodDef && methodDef.requestType && methodDef.requestType.format === 'Protocol Buffer 3 DescriptorProto') {
+                        for (const field of methodDef.requestType.type.field) {
+                            if (field.typeName === 'google.protobuf.Struct' && request[field.name]) {
+                                // Convert Struct -> JSON for the handler
+                                request[field.name] = structToJson(request[field.name]);
+                            }
+                        }
+                    }
+
+                    const result = await handler.handler(request);
+
+                    // Introspect Response for Struct fields and wrap JSON to Struct
+                    if (result && typeof result === 'object' && methodDef && methodDef.responseType && methodDef.responseType.format === 'Protocol Buffer 3 DescriptorProto') {
+                        for (const field of methodDef.responseType.type.field) {
+                            if (field.typeName === 'google.protobuf.Struct' && result[field.name]) {
+                                // Convert JSON -> Struct for the callback
+                                result[field.name] = jsonToStruct(result[field.name]);
+                            }
+                        }
+                    }
+
                     callback(null, result);
                 } catch (error: any) {
                     console.error(`gRPC Error in ${handler.name}:`, error);

package/src/grpc/struct-utils.ts

@@ -0,0 +1,73 @@
+/**
+ * Utilities for converting between JSON/JS Objects and google.protobuf.Struct
+ */
+
+/**
+ * Convert a plain JS object/value to google.protobuf.Value
+ */
+export function jsonToValue(val: any): any {
+    if (val === null || val === undefined) {
+        return { nullValue: 0 };
+    }
+    if (typeof val === 'number') {
+        return { numberValue: val };
+    }
+    if (typeof val === 'string') {
+        return { stringValue: val };
+    }
+    if (typeof val === 'boolean') {
+        return { boolValue: val };
+    }
+    if (Array.isArray(val)) {
+        return { listValue: { values: val.map(jsonToValue) } };
+    }
+    if (typeof val === 'object') {
+        return { structValue: jsonToStruct(val) };
+    }
+    throw new Error(`Unsupported type for Struct conversion: ${typeof val}`);
+}
+
+/**
+ * Convert a plain JS object to google.protobuf.Struct
+ */
+export function jsonToStruct(json: any): any {
+    const fields: Record<string, any> = {};
+    for (const k in json) {
+        if (Object.prototype.hasOwnProperty.call(json, k)) {
+            fields[k] = jsonToValue(json[k]);
+        }
+    }
+    return { fields };
+}
+
+/**
+ * Convert google.protobuf.Value to JS value
+ */
+export function valueToJson(val: any): any {
+    if (!val) return null;
+    if ('nullValue' in val) return null;
+    if ('numberValue' in val) return val.numberValue;
+    if ('stringValue' in val) return val.stringValue;
+    if ('boolValue' in val) return val.boolValue;
+    if ('listValue' in val) {
+        return (val.listValue.values || []).map(valueToJson);
+    }
+    if ('structValue' in val) {
+        return structToJson(val.structValue);
+    }
+    // Fallback if 'kind' oneof logic is different in some implementations,
+    // but usually keys are explicit.
+    return null;
+}
+
+/**
+ * Convert google.protobuf.Struct to plain JS object
+ */
+export function structToJson(struct: any): any {
+    if (!struct || !struct.fields) return {};
+    const json: Record<string, any> = {};
+    for (const k in struct.fields) {
+        json[k] = valueToJson(struct.fields[k]);
+    }
+    return json;
+}

package/src/proto-generator/index.ts

@@ -8,12 +8,12 @@ import * as path from 'path';
  * @example
  * requestSample: () => ({ id: '', data: AnyType })
  */
-export const AnyType = Symbol('google.protobuf.Any');
+export const AnyType = Symbol('google.protobuf.Struct');
 
 /**
  * Maps JavaScript/TypeScript runtime types to Protobuf types.
  */
-type ProtoType = "double" | "float" | "int32" | "int64" | "bool" | "string" | "bytes" | "google.protobuf.Any" | string;
+type ProtoType = "double" | "float" | "int32" | "int64" | "bool" | "string" | "bytes" | "google.protobuf.Struct" | string;
 
 interface ProtoField {
     name: string;
@@ -109,8 +109,8 @@ export function generateProtoFromMethods(
             const valueType = typeof value;
 
             // Check for AnyType marker symbol
-            if (enableAnyType && (value === AnyType || (typeof value === 'symbol' && value.description === 'google.protobuf.Any'))) {
-                type = "google.protobuf.Any";
+            if (enableAnyType && (value === AnyType || (typeof value === 'symbol' && value.description === 'google.protobuf.Any') || (typeof value === 'symbol' && value.description === 'google.protobuf.Struct'))) {
+                type = "google.protobuf.Struct";
                 usesAnyType = true;
             } else if (value === null || value === undefined) {
                 type = "string";
@@ -183,9 +183,9 @@ export function generateProtoFromMethods(
         lines.push(`package ${packageName};`, '');
     }
 
-    // Add google.protobuf.Any import if needed
+    // Add google.protobuf.Struct import if needed
     if (usesAnyType) {
-        lines.push('import "google/protobuf/any.proto";', '');
+        lines.push('import "google/protobuf/struct.proto";', '');
     }
 
     // Service definition

package/tests/{any-type.spec.ts → struct-support.spec.ts}

@@ -1,14 +1,14 @@
 import { describe, it, expect } from 'vitest';
 import { generateProtoFromMethods, AnyType } from '../src/index';
 
-describe('google.protobuf.Any support', () => {
-    it('should export AnyType symbol', () => {
+describe('google.protobuf.Struct support', () => {
+    it('should export AnyType symbol aliased to Struct', () => {
         expect(AnyType).toBeDefined();
         expect(typeof AnyType).toBe('symbol');
-        expect(AnyType.description).toBe('google.protobuf.Any');
+        expect(AnyType.description).toBe('google.protobuf.Struct');
     });
 
-    it('should generate proto with google.protobuf.Any for marked fields', () => {
+    it('should generate proto with google.protobuf.Struct for marked fields', () => {
         const proto = generateProtoFromMethods([
             {
                 name: 'ProcessGenericData',
@@ -27,14 +27,14 @@ describe('google.protobuf.Any support', () => {
         });
 
         // Should include the import statement
-        expect(proto).toContain('import "google/protobuf/any.proto";');
+        expect(proto).toContain('import "google/protobuf/struct.proto";');
 
-        // Should use google.protobuf.Any type
-        expect(proto).toContain('google.protobuf.Any data = 2;');
-        expect(proto).toContain('google.protobuf.Any result = 2;');
+        // Should use google.protobuf.Struct type
+        expect(proto).toContain('google.protobuf.Struct data = 2;');
+        expect(proto).toContain('google.protobuf.Struct result = 2;');
     });
 
-    it('should not include import if no Any types are used', () => {
+    it('should not include import if no Struct types are used', () => {
         const proto = generateProtoFromMethods([
             {
                 name: 'SimpleMethod',
@@ -46,11 +46,11 @@ describe('google.protobuf.Any support', () => {
             serviceName: 'SimpleService',
         });
 
-        expect(proto).not.toContain('import "google/protobuf/any.proto";');
-        expect(proto).not.toContain('google.protobuf.Any');
+        expect(proto).not.toContain('import "google/protobuf/struct.proto";');
+        expect(proto).not.toContain('google.protobuf.Struct');
     });
 
-    it('should handle mixed fields with some Any types', () => {
+    it('should handle mixed fields with some Struct types', () => {
         const proto = generateProtoFromMethods([
             {
                 name: 'MixedMethod',
@@ -70,10 +70,10 @@ describe('google.protobuf.Any support', () => {
             serviceName: 'MixedService',
         });
 
-        expect(proto).toContain('import "google/protobuf/any.proto";');
+        expect(proto).toContain('import "google/protobuf/struct.proto";');
         expect(proto).toContain('string id = 1;');
         expect(proto).toContain('string name = 2;');
-        expect(proto).toContain('google.protobuf.Any metadata = 3;');
+        expect(proto).toContain('google.protobuf.Struct metadata = 3;');
         expect(proto).toContain('int32 count = 4;');
     });
 
@@ -94,7 +94,7 @@ describe('google.protobuf.Any support', () => {
         });
 
         // When disabled, AnyType should be treated as a regular value (string fallback)
-        expect(proto).not.toContain('import "google/protobuf/any.proto";');
-        expect(proto).not.toContain('google.protobuf.Any');
+        expect(proto).not.toContain('import "google/protobuf/struct.proto";');
+        expect(proto).not.toContain('google.protobuf.Struct');
     });
 });