@themainstack/communication 1.0.2 → 1.1.1

package/README.md

@@ -182,6 +182,7 @@ See `examples/full-grpc-demo.ts` in the repository for a complete working exampl
 ### Proto Generation
 - `generateProtoFromMethods(methods, options)` - Generate proto with service definition
 - `generateProtoFromFunction(fn, name)` - Generate proto for a single message
+- `AnyType` - Marker symbol for `google.protobuf.Any` dynamic fields
 
 ### Server
 - `GrpcServerFactory.createServer(options, handlers)` - Create a gRPC server

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/index.d.ts

@@ -9,7 +9,7 @@
  * 3. Client Factory - Call gRPC services from other services
  * 4. Error Handling - Standardized error translation
  */
-export { generateProtoFromMethods, generateProtoFromFunction } from './proto-generator';
+export { generateProtoFromMethods, generateProtoFromFunction, AnyType } from './proto-generator';
 export type { MethodDefinition, GenerateProtoOptions } from './proto-generator';
 export { GrpcServerFactory, exposeAsGrpc } from './grpc/server-factory';
 export type { GrpcServerOptions, ServerMethodHandler } from './grpc/server-factory';

package/dist/index.js

@@ -11,12 +11,13 @@
  * 4. Error Handling - Standardized error translation
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GrpcError = exports.handleGrpcError = exports.GrpcClientFactory = exports.exposeAsGrpc = exports.GrpcServerFactory = exports.generateProtoFromFunction = exports.generateProtoFromMethods = void 0;
+exports.GrpcError = exports.handleGrpcError = exports.GrpcClientFactory = exports.exposeAsGrpc = exports.GrpcServerFactory = exports.AnyType = exports.generateProtoFromFunction = exports.generateProtoFromMethods = void 0;
 // Proto Generation
 // Auto-generate .proto files from TypeScript types
 var proto_generator_1 = require("./proto-generator");
 Object.defineProperty(exports, "generateProtoFromMethods", { enumerable: true, get: function () { return proto_generator_1.generateProtoFromMethods; } });
 Object.defineProperty(exports, "generateProtoFromFunction", { enumerable: true, get: function () { return proto_generator_1.generateProtoFromFunction; } });
+Object.defineProperty(exports, "AnyType", { enumerable: true, get: function () { return proto_generator_1.AnyType; } });
 // Server Factory
 // Expose existing functions as gRPC endpoints
 var server_factory_1 = require("./grpc/server-factory");

package/dist/proto-generator/index.d.ts

@@ -1,3 +1,11 @@
+/**
+ * Marker symbol to indicate a field should use google.protobuf.Any type.
+ * Use this in your sample objects to mark dynamic/generic fields.
+ *
+ * @example
+ * requestSample: () => ({ id: '', data: AnyType })
+ */
+export declare const AnyType: unique symbol;
 /**
  * Options for generating a proto file
  */
@@ -10,6 +18,8 @@ export interface GenerateProtoOptions {
     outputDir?: string;
     /** Output filename (default: derived from serviceName or 'generated.proto') */
     outputFilename?: string;
+    /** Enable google.protobuf.Any for dynamic types marked with AnyType symbol (default: true) */
+    enableAnyType?: boolean;
 }
 /**
  * Definition of a gRPC method with request and response generators

package/dist/proto-generator/index.js

@@ -33,10 +33,19 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnyType = void 0;
 exports.generateProtoFromMethods = generateProtoFromMethods;
 exports.generateProtoFromFunction = generateProtoFromFunction;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+/**
+ * Marker symbol to indicate a field should use google.protobuf.Any type.
+ * Use this in your sample objects to mark dynamic/generic fields.
+ *
+ * @example
+ * requestSample: () => ({ id: '', data: AnyType })
+ */
+exports.AnyType = Symbol('google.protobuf.Struct');
 /**
  * Generate a complete .proto file from method definitions
  *
@@ -45,10 +54,11 @@ const path = __importStar(require("path"));
  * @returns The generated proto string
  */
 function generateProtoFromMethods(methods, options = {}) {
-    const { packageName, serviceName = 'GeneratedService', outputDir, outputFilename } = options;
+    const { packageName, serviceName = 'GeneratedService', outputDir, outputFilename, enableAnyType = true } = options;
     const messages = [];
     const protoMethods = [];
     const processedObjects = new Set();
+    let usesAnyType = false;
     // Helper: Capitalize string
     function capitalize(s) {
         return s.charAt(0).toUpperCase() + s.slice(1);
@@ -72,7 +82,12 @@ function generateProtoFromMethods(methods, options = {}) {
             let type = "string";
             let rule = undefined;
             const valueType = typeof value;
-            if (value === null || value === undefined) {
+            // Check for AnyType marker symbol
+            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) {
                 type = "string";
             }
             else if (valueType === "string") {
@@ -140,6 +155,10 @@ function generateProtoFromMethods(methods, options = {}) {
     if (packageName) {
         lines.push(`package ${packageName};`, '');
     }
+    // Add google.protobuf.Struct import if needed
+    if (usesAnyType) {
+        lines.push('import "google/protobuf/struct.proto";', '');
+    }
     // Service definition
     lines.push(`// ${serviceName} - Auto-generated gRPC service`);
     lines.push(`service ${serviceName} {`);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@themainstack/communication",
-    "version": "1.0.2",
+    "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",
@@ -23,4 +23,4 @@
         "@grpc/grpc-js": "^1.14.3",
         "@grpc/proto-loader": "^0.8.0"
     }
-}
+}

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/index.ts

@@ -14,7 +14,8 @@
 // Auto-generate .proto files from TypeScript types
 export {
     generateProtoFromMethods,
-    generateProtoFromFunction
+    generateProtoFromFunction,
+    AnyType
 } from './proto-generator';
 export type {
     MethodDefinition,

package/src/proto-generator/index.ts

@@ -1,10 +1,19 @@
 import * as fs from 'fs';
 import * as path from 'path';
 
+/**
+ * Marker symbol to indicate a field should use google.protobuf.Any type.
+ * Use this in your sample objects to mark dynamic/generic fields.
+ * 
+ * @example
+ * requestSample: () => ({ id: '', data: AnyType })
+ */
+export const AnyType = Symbol('google.protobuf.Struct');
+
 /**
  * Maps JavaScript/TypeScript runtime types to Protobuf types.
  */
-type ProtoType = "double" | "float" | "int32" | "int64" | "bool" | "string" | "bytes" | string;
+type ProtoType = "double" | "float" | "int32" | "int64" | "bool" | "string" | "bytes" | "google.protobuf.Struct" | string;
 
 interface ProtoField {
     name: string;
@@ -36,6 +45,8 @@ export interface GenerateProtoOptions {
     outputDir?: string;
     /** Output filename (default: derived from serviceName or 'generated.proto') */
     outputFilename?: string;
+    /** Enable google.protobuf.Any for dynamic types marked with AnyType symbol (default: true) */
+    enableAnyType?: boolean;
 }
 
 /**
@@ -61,11 +72,12 @@ export function generateProtoFromMethods(
     methods: MethodDefinition<any, any>[],
     options: GenerateProtoOptions = {}
 ): string {
-    const { packageName, serviceName = 'GeneratedService', outputDir, outputFilename } = options;
+    const { packageName, serviceName = 'GeneratedService', outputDir, outputFilename, enableAnyType = true } = options;
 
     const messages: ProtoMessage[] = [];
     const protoMethods: ProtoMethod[] = [];
     const processedObjects = new Set<object>();
+    let usesAnyType = false;
 
     // Helper: Capitalize string
     function capitalize(s: string): string {
@@ -96,7 +108,11 @@ export function generateProtoFromMethods(
 
             const valueType = typeof value;
 
-            if (value === null || value === undefined) {
+            // Check for AnyType marker symbol
+            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";
             } else if (valueType === "string") {
                 type = "string";
@@ -167,6 +183,11 @@ export function generateProtoFromMethods(
         lines.push(`package ${packageName};`, '');
     }
 
+    // Add google.protobuf.Struct import if needed
+    if (usesAnyType) {
+        lines.push('import "google/protobuf/struct.proto";', '');
+    }
+
     // Service definition
     lines.push(`// ${serviceName} - Auto-generated gRPC service`);
     lines.push(`service ${serviceName} {`);

package/tests/struct-support.spec.ts

@@ -0,0 +1,100 @@
+import { describe, it, expect } from 'vitest';
+import { generateProtoFromMethods, AnyType } from '../src/index';
+
+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.Struct');
+    });
+
+    it('should generate proto with google.protobuf.Struct for marked fields', () => {
+        const proto = generateProtoFromMethods([
+            {
+                name: 'ProcessGenericData',
+                requestSample: () => ({
+                    id: '',
+                    data: AnyType,
+                }),
+                responseSample: () => ({
+                    success: true,
+                    result: AnyType,
+                }),
+            }
+        ], {
+            packageName: 'generic.v1',
+            serviceName: 'GenericService',
+        });
+
+        // Should include the import statement
+        expect(proto).toContain('import "google/protobuf/struct.proto";');
+
+        // 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 Struct types are used', () => {
+        const proto = generateProtoFromMethods([
+            {
+                name: 'SimpleMethod',
+                requestSample: () => ({ id: '', amount: 0 }),
+                responseSample: () => ({ success: true }),
+            }
+        ], {
+            packageName: 'simple.v1',
+            serviceName: 'SimpleService',
+        });
+
+        expect(proto).not.toContain('import "google/protobuf/struct.proto";');
+        expect(proto).not.toContain('google.protobuf.Struct');
+    });
+
+    it('should handle mixed fields with some Struct types', () => {
+        const proto = generateProtoFromMethods([
+            {
+                name: 'MixedMethod',
+                requestSample: () => ({
+                    id: '',
+                    name: 'test',
+                    metadata: AnyType,
+                    count: 0,
+                }),
+                responseSample: () => ({
+                    status: 'ok',
+                    payload: AnyType,
+                }),
+            }
+        ], {
+            packageName: 'mixed.v1',
+            serviceName: 'MixedService',
+        });
+
+        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.Struct metadata = 3;');
+        expect(proto).toContain('int32 count = 4;');
+    });
+
+    it('should respect enableAnyType: false option', () => {
+        const proto = generateProtoFromMethods([
+            {
+                name: 'DisabledAny',
+                requestSample: () => ({
+                    id: '',
+                    data: AnyType,
+                }),
+                responseSample: () => ({ success: true }),
+            }
+        ], {
+            packageName: 'test.v1',
+            serviceName: 'TestService',
+            enableAnyType: false,
+        });
+
+        // When disabled, AnyType should be treated as a regular value (string fallback)
+        expect(proto).not.toContain('import "google/protobuf/struct.proto";');
+        expect(proto).not.toContain('google.protobuf.Struct');
+    });
+});

package/publish-config.npmrc

@@ -1 +0,0 @@
-//registry.npmjs.org/:_authToken=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