@rocketmq/protobuf 0.1.0 → 0.1.2

package/.turbo/turbo-build.log

@@ -1,21 +1,23 @@
 
 
-> @rocketmq/protobuf@0.1.0 build /home/edilson/learnspace/rocketmq-broker/client-ts/packages/protobuf
+> @rocketmq/protobuf@0.1.2 build /home/edilson/learnspace/rocketmq-broker/rocketmq.js/packages/protobuf
 > tsup
 
 CLI Building entry: src/index.ts
 CLI Using tsconfig: tsconfig.json
 CLI tsup v8.5.1
-CLI Using tsup config: /home/edilson/learnspace/rocketmq-broker/client-ts/packages/protobuf/tsup.config.ts
+CLI Using tsup config: /home/edilson/learnspace/rocketmq-broker/rocketmq.js/packages/protobuf/tsup.config.ts
 CLI Target: es2022
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-CJS dist/index.cjs 1.65 KB
-CJS ⚡️ Build success in 10ms
-ESM dist/index.js 645.00 B
-ESM ⚡️ Build success in 10ms
+CJS dist/index.cjs     4.97 KB
+CJS dist/index.cjs.map 8.75 KB
+CJS ⚡️ Build success in 17ms
+ESM dist/index.js     3.88 KB
+ESM dist/index.js.map 8.63 KB
+ESM ⚡️ Build success in 17ms
 DTS Build start
-DTS ⚡️ Build success in 896ms
-DTS dist/index.d.ts  581.00 B
-DTS dist/index.d.cts 581.00 B
+DTS ⚡️ Build success in 483ms
+DTS dist/index.d.ts  1.24 KB
+DTS dist/index.d.cts 1.24 KB

package/CHANGELOG.md

@@ -0,0 +1,10 @@
+# @rocketmq/protobuf
+
+## 0.1.2
+
+### Patch Changes
+
+- docs: comprehensive README and API docs like Python SDK
+
+- Updated dependencies []:
+  - @rocketmq/schema@0.1.2

package/README.md

@@ -0,0 +1,26 @@
+# @rocketmq/protobuf
+
+Protobuf generation utilities for RocketMQ.
+
+This package translates TypeScript schema metadata (gathered via `@rocketmq/schema` decorators) into dynamic Protobuf v3 definitions. These definitions are passed as AMQP headers to the broker, enabling native, broker-side schema validation without requiring a separate schema registry service.
+
+## Installation
+
+```bash
+npm install @rocketmq/protobuf
+```
+
+## Usage
+
+This is an internal package used by `@rocketmq/core`.
+
+```typescript
+import { toProto } from '@rocketmq/protobuf';
+
+// Translates a decorated class into a proto3 definition string
+const protoDefinition = toProto(MyDecoratedClass);
+```
+
+## License
+
+Apache 2.0

package/dist/index.cjs

@@ -3,6 +3,7 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -20,6 +21,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  fieldsToProto: () => fieldsToProto,
   toProto: () => toProto
 });
 module.exports = __toCommonJS(index_exports);
@@ -33,16 +35,109 @@ function ensureFieldsRegistered(schema) {
   } catch {
   }
 }
-function toProto(schema) {
-  ensureFieldsRegistered(schema);
+__name(ensureFieldsRegistered, "ensureFieldsRegistered");
+function collectDependentSchemas(schema, seen = /* @__PURE__ */ new Set(), orderedList = []) {
+  if (seen.has(schema)) return orderedList;
+  seen.add(schema);
+  const fields = import_schema.defaultRegistry.getFields(schema);
+  for (const field of fields) {
+    if (field.reflectedType && import_schema.defaultRegistry.isSchema(field.reflectedType)) {
+      collectDependentSchemas(field.reflectedType, seen, orderedList);
+    }
+    if (field.type) {
+      const depSchema = import_schema.defaultRegistry.getSchemaByName(field.type);
+      if (depSchema) {
+        collectDependentSchemas(depSchema, seen, orderedList);
+      }
+    }
+  }
+  orderedList.push(schema);
+  return orderedList;
+}
+__name(collectDependentSchemas, "collectDependentSchemas");
+function needsTimestamp(schemas) {
+  return schemas.some((s) => import_schema.defaultRegistry.getFields(s).some((f) => f.protoType === "google.protobuf.Timestamp"));
+}
+__name(needsTimestamp, "needsTimestamp");
+function buildFieldLine(field) {
+  const modifier = field.repeated ? "repeated " : field.optional ? "optional " : "";
+  return `${modifier}${field.protoType} ${field.name} = ${field.number};`;
+}
+__name(buildFieldLine, "buildFieldLine");
+function buildMessageBlock(schema, lines) {
   const fields = import_schema.defaultRegistry.getFields(schema);
   if (fields.length === 0) {
     throw new Error(`Schema '${schema.name}' has no @Field() decorators \u2014 cannot generate proto`);
   }
-  const body = fields.map((f) => `${f.protoType} ${f.name} = ${f.number};`).join(" ");
-  return `syntax = "proto3"; message ${schema.name} { ${body} }`;
+  lines.push(`message ${schema.name} {`);
+  for (const field of fields) {
+    if (field.comment) {
+      lines.push(`  // ${field.comment}`);
+    }
+    lines.push(`  ${buildFieldLine(field)}`);
+  }
+  lines.push("}", "");
+}
+__name(buildMessageBlock, "buildMessageBlock");
+function toProto(schema) {
+  ensureFieldsRegistered(schema);
+  const orderedList = collectDependentSchemas(schema);
+  if (orderedList.length === 0 || import_schema.defaultRegistry.getFields(schema).length === 0) {
+    throw new Error(`Schema '${schema.name}' has no @Field() decorators \u2014 cannot generate proto`);
+  }
+  const lines = [
+    'syntax = "proto3";',
+    ""
+  ];
+  if (needsTimestamp(orderedList)) {
+    lines.push('import "google/protobuf/timestamp.proto";', "");
+  }
+  for (const s of orderedList) {
+    buildMessageBlock(s, lines);
+  }
+  return lines.join("\n").trimEnd();
+}
+__name(toProto, "toProto");
+
+// src/fields-to-proto.ts
+function buildFieldLine2(field) {
+  const modifier = field.repeated ? "repeated " : field.optional ? "optional " : "";
+  return `${modifier}${field.protoType} ${field.name} = ${field.number};`;
+}
+__name(buildFieldLine2, "buildFieldLine");
+function needsTimestampImport(fields) {
+  return fields.some((f) => f.protoType === "google.protobuf.Timestamp");
+}
+__name(needsTimestampImport, "needsTimestampImport");
+function appendMessageBlock(messageName, fields, lines) {
+  if (fields.length === 0) {
+    throw new Error(`Schema '${messageName}' has no fields \u2014 cannot generate proto. Got 0 fields.`);
+  }
+  lines.push(`message ${messageName} {`);
+  for (const field of fields) {
+    if (field.comment) {
+      lines.push(`  // ${field.comment}`);
+    }
+    lines.push(`  ${buildFieldLine2(field)}`);
+  }
+  lines.push("}", "");
+}
+__name(appendMessageBlock, "appendMessageBlock");
+function fieldsToProto(messageName, fields) {
+  const lines = [
+    'syntax = "proto3";',
+    ""
+  ];
+  if (needsTimestampImport(fields)) {
+    lines.push('import "google/protobuf/timestamp.proto";', "");
+  }
+  appendMessageBlock(messageName, fields, lines);
+  return lines.join("\n").trimEnd();
 }
+__name(fieldsToProto, "fieldsToProto");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  fieldsToProto,
   toProto
 });
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/generator.ts","../src/fields-to-proto.ts"],"sourcesContent":["export { toProto } from './generator.js';\nexport { fieldsToProto } from './fields-to-proto.js';\n","/**\n * Generates a proto3 schema string from a decorated class.\n *\n * Reads field metadata from the default SchemaRegistry and produces\n * the exact format the Rust broker expects in the `x-schema` queue argument.\n */\n\nimport { defaultRegistry, type FieldMeta, type Constructor } from '@rocketmq/schema';\n\n/** Forces field registration by instantiating the class once. */\nfunction ensureFieldsRegistered(schema: Constructor): void {\n  if (defaultRegistry.getFields(schema).length > 0) return;\n  try {\n    new schema();\n  } catch {\n    // Constructor may throw — fields are registered via addInitializer\n    void 0;\n  }\n}\n\n/** Recursively collects all schema constructors referenced by the class. */\nfunction collectDependentSchemas(\n  schema: Constructor,\n  seen = new Set<Constructor>(),\n  orderedList: Constructor[] = [],\n): Constructor[] {\n  if (seen.has(schema)) return orderedList;\n  seen.add(schema);\n\n  const fields = defaultRegistry.getFields(schema);\n  for (const field of fields) {\n    if (field.reflectedType && defaultRegistry.isSchema(field.reflectedType)) {\n      collectDependentSchemas(field.reflectedType, seen, orderedList);\n    }\n    if (field.type) {\n      const depSchema = defaultRegistry.getSchemaByName(field.type);\n      if (depSchema) {\n        collectDependentSchemas(depSchema, seen, orderedList);\n      }\n    }\n  }\n  orderedList.push(schema);\n  return orderedList;\n}\n\n/** Determines if any schema in the list uses a Timestamp type. */\nfunction needsTimestamp(schemas: Constructor[]): boolean {\n  return schemas.some((s) =>\n    defaultRegistry.getFields(s).some((f) => f.protoType === 'google.protobuf.Timestamp'),\n  );\n}\n\n/** Builds the protobuf field line using the pre-resolved protoType. */\nfunction buildFieldLine(field: FieldMeta): string {\n  const modifier = field.repeated ? 'repeated ' : field.optional ? 'optional ' : '';\n  return `${modifier}${field.protoType} ${field.name} = ${field.number};`;\n}\n\n/** Formats a schema class as a protobuf message block. */\nfunction buildMessageBlock(schema: Constructor, lines: string[]): void {\n  const fields = defaultRegistry.getFields(schema);\n  if (fields.length === 0) {\n    throw new Error(`Schema '${schema.name}' has no @Field() decorators — cannot generate proto`);\n  }\n  lines.push(`message ${schema.name} {`);\n  for (const field of fields) {\n    if (field.comment) {\n      lines.push(`  // ${field.comment}`);\n    }\n    lines.push(`  ${buildFieldLine(field)}`);\n  }\n  lines.push('}', '');\n}\n\n/** Converts a decorated schema class to a proto3 definition string. */\nexport function toProto(schema: Constructor): string {\n  ensureFieldsRegistered(schema);\n  const orderedList = collectDependentSchemas(schema);\n  if (orderedList.length === 0 || defaultRegistry.getFields(schema).length === 0) {\n    throw new Error(`Schema '${schema.name}' has no @Field() decorators — cannot generate proto`);\n  }\n  const lines: string[] = ['syntax = \"proto3\";', ''];\n  if (needsTimestamp(orderedList)) {\n    lines.push('import \"google/protobuf/timestamp.proto\";', '');\n  }\n  for (const s of orderedList) {\n    buildMessageBlock(s, lines);\n  }\n  return lines.join('\\n').trimEnd();\n}\n","/**\n * Generates proto3 from raw FieldMeta arrays — no class/decorator dependency.\n *\n * This is the shared codegen path used by both the decorator-based `toProto()`\n * and the Zod-based `zodToProto()` pipelines. Factoring it here avoids\n * duplicating proto string assembly logic.\n *\n * Usage:\n *   fieldsToProto('Order', [{ name: 'id', protoType: 'string', number: 1 }]);\n */\n\nimport type { FieldMeta } from '@rocketmq/schema';\n\n/** Builds a single proto3 field line from resolved metadata. */\nfunction buildFieldLine(field: FieldMeta): string {\n  const modifier = field.repeated ? 'repeated ' : field.optional ? 'optional ' : '';\n  return `${modifier}${field.protoType} ${field.name} = ${field.number};`;\n}\n\n/**\n * Checks whether any field in the list needs the Timestamp import.\n *\n * Extracted so callers don't need to know the magic string.\n */\nfunction needsTimestampImport(fields: FieldMeta[]): boolean {\n  return fields.some((f) => f.protoType === 'google.protobuf.Timestamp');\n}\n\n/** Appends one protobuf message block to the output lines array. */\nfunction appendMessageBlock(messageName: string, fields: FieldMeta[], lines: string[]): void {\n  if (fields.length === 0) {\n    throw new Error(`Schema '${messageName}' has no fields — cannot generate proto. Got 0 fields.`);\n  }\n  lines.push(`message ${messageName} {`);\n  for (const field of fields) {\n    if (field.comment) {\n      lines.push(`  // ${field.comment}`);\n    }\n    lines.push(`  ${buildFieldLine(field)}`);\n  }\n  lines.push('}', '');\n}\n\n/**\n * Converts a message name + field metadata list into a proto3 definition.\n *\n * This is the low-level entrypoint — no class introspection, no registry\n * lookups. Works with any source that can produce `FieldMeta[]`.\n *\n * Usage:\n *   const proto = fieldsToProto('Notification', fields);\n *   // => 'syntax = \"proto3\";\\n\\nmessage Notification { ... }'\n */\nexport function fieldsToProto(messageName: string, fields: FieldMeta[]): string {\n  const lines: string[] = ['syntax = \"proto3\";', ''];\n  if (needsTimestampImport(fields)) {\n    lines.push('import \"google/protobuf/timestamp.proto\";', '');\n  }\n  appendMessageBlock(messageName, fields, lines);\n  return lines.join('\\n').trimEnd();\n}\n"],"mappings":"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","names":["ensureFieldsRegistered","schema","defaultRegistry","getFields","length","collectDependentSchemas","seen","Set","orderedList","has","add","fields","field","reflectedType","isSchema","type","depSchema","getSchemaByName","push","needsTimestamp","schemas","some","s","f","protoType","buildFieldLine","modifier","repeated","optional","name","number","buildMessageBlock","lines","Error","comment","toProto","join","trimEnd","buildFieldLine","field","modifier","repeated","optional","protoType","name","number","needsTimestampImport","fields","some","f","appendMessageBlock","messageName","lines","length","Error","push","comment","fieldsToProto","join","trimEnd"]}

package/dist/index.d.cts

@@ -1,18 +1,36 @@
+import { Constructor, FieldMeta } from '@rocketmq/schema';
+
 /**
  * Generates a proto3 schema string from a decorated class.
  *
  * Reads field metadata from the default SchemaRegistry and produces
  * the exact format the Rust broker expects in the `x-schema` queue argument.
+ */
+
+/** Converts a decorated schema class to a proto3 definition string. */
+declare function toProto(schema: Constructor): string;
+
+/**
+ * Generates proto3 from raw FieldMeta arrays — no class/decorator dependency.
+ *
+ * This is the shared codegen path used by both the decorator-based `toProto()`
+ * and the Zod-based `zodToProto()` pipelines. Factoring it here avoids
+ * duplicating proto string assembly logic.
  *
  * Usage:
- *   const proto = toProto(NotificationClass);
- *   // => 'syntax = "proto3"; message Notification { string id = 1; int64 timestamp = 2; }'
+ *   fieldsToProto('Order', [{ name: 'id', protoType: 'string', number: 1 }]);
  */
+
 /**
- * Converts a decorated schema class to a proto3 definition string.
+ * Converts a message name + field metadata list into a proto3 definition.
  *
- * @throws Error if the class has no @Field() decorators.
+ * This is the low-level entrypoint — no class introspection, no registry
+ * lookups. Works with any source that can produce `FieldMeta[]`.
+ *
+ * Usage:
+ *   const proto = fieldsToProto('Notification', fields);
+ *   // => 'syntax = "proto3";\n\nmessage Notification { ... }'
  */
-declare function toProto(schema: Function): string;
+declare function fieldsToProto(messageName: string, fields: FieldMeta[]): string;
 
-export { toProto };
+export { fieldsToProto, toProto };

package/dist/index.d.ts

@@ -1,18 +1,36 @@
+import { Constructor, FieldMeta } from '@rocketmq/schema';
+
 /**
  * Generates a proto3 schema string from a decorated class.
  *
  * Reads field metadata from the default SchemaRegistry and produces
  * the exact format the Rust broker expects in the `x-schema` queue argument.
+ */
+
+/** Converts a decorated schema class to a proto3 definition string. */
+declare function toProto(schema: Constructor): string;
+
+/**
+ * Generates proto3 from raw FieldMeta arrays — no class/decorator dependency.
+ *
+ * This is the shared codegen path used by both the decorator-based `toProto()`
+ * and the Zod-based `zodToProto()` pipelines. Factoring it here avoids
+ * duplicating proto string assembly logic.
  *
  * Usage:
- *   const proto = toProto(NotificationClass);
- *   // => 'syntax = "proto3"; message Notification { string id = 1; int64 timestamp = 2; }'
+ *   fieldsToProto('Order', [{ name: 'id', protoType: 'string', number: 1 }]);
  */
+
 /**
- * Converts a decorated schema class to a proto3 definition string.
+ * Converts a message name + field metadata list into a proto3 definition.
  *
- * @throws Error if the class has no @Field() decorators.
+ * This is the low-level entrypoint — no class introspection, no registry
+ * lookups. Works with any source that can produce `FieldMeta[]`.
+ *
+ * Usage:
+ *   const proto = fieldsToProto('Notification', fields);
+ *   // => 'syntax = "proto3";\n\nmessage Notification { ... }'
  */
-declare function toProto(schema: Function): string;
+declare function fieldsToProto(messageName: string, fields: FieldMeta[]): string;
 
-export { toProto };
+export { fieldsToProto, toProto };

package/dist/index.js

@@ -1,3 +1,6 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
 // src/generator.ts
 import { defaultRegistry } from "@rocketmq/schema";
 function ensureFieldsRegistered(schema) {
@@ -7,15 +10,108 @@ function ensureFieldsRegistered(schema) {
   } catch {
   }
 }
-function toProto(schema) {
-  ensureFieldsRegistered(schema);
+__name(ensureFieldsRegistered, "ensureFieldsRegistered");
+function collectDependentSchemas(schema, seen = /* @__PURE__ */ new Set(), orderedList = []) {
+  if (seen.has(schema)) return orderedList;
+  seen.add(schema);
+  const fields = defaultRegistry.getFields(schema);
+  for (const field of fields) {
+    if (field.reflectedType && defaultRegistry.isSchema(field.reflectedType)) {
+      collectDependentSchemas(field.reflectedType, seen, orderedList);
+    }
+    if (field.type) {
+      const depSchema = defaultRegistry.getSchemaByName(field.type);
+      if (depSchema) {
+        collectDependentSchemas(depSchema, seen, orderedList);
+      }
+    }
+  }
+  orderedList.push(schema);
+  return orderedList;
+}
+__name(collectDependentSchemas, "collectDependentSchemas");
+function needsTimestamp(schemas) {
+  return schemas.some((s) => defaultRegistry.getFields(s).some((f) => f.protoType === "google.protobuf.Timestamp"));
+}
+__name(needsTimestamp, "needsTimestamp");
+function buildFieldLine(field) {
+  const modifier = field.repeated ? "repeated " : field.optional ? "optional " : "";
+  return `${modifier}${field.protoType} ${field.name} = ${field.number};`;
+}
+__name(buildFieldLine, "buildFieldLine");
+function buildMessageBlock(schema, lines) {
   const fields = defaultRegistry.getFields(schema);
   if (fields.length === 0) {
     throw new Error(`Schema '${schema.name}' has no @Field() decorators \u2014 cannot generate proto`);
   }
-  const body = fields.map((f) => `${f.protoType} ${f.name} = ${f.number};`).join(" ");
-  return `syntax = "proto3"; message ${schema.name} { ${body} }`;
+  lines.push(`message ${schema.name} {`);
+  for (const field of fields) {
+    if (field.comment) {
+      lines.push(`  // ${field.comment}`);
+    }
+    lines.push(`  ${buildFieldLine(field)}`);
+  }
+  lines.push("}", "");
+}
+__name(buildMessageBlock, "buildMessageBlock");
+function toProto(schema) {
+  ensureFieldsRegistered(schema);
+  const orderedList = collectDependentSchemas(schema);
+  if (orderedList.length === 0 || defaultRegistry.getFields(schema).length === 0) {
+    throw new Error(`Schema '${schema.name}' has no @Field() decorators \u2014 cannot generate proto`);
+  }
+  const lines = [
+    'syntax = "proto3";',
+    ""
+  ];
+  if (needsTimestamp(orderedList)) {
+    lines.push('import "google/protobuf/timestamp.proto";', "");
+  }
+  for (const s of orderedList) {
+    buildMessageBlock(s, lines);
+  }
+  return lines.join("\n").trimEnd();
+}
+__name(toProto, "toProto");
+
+// src/fields-to-proto.ts
+function buildFieldLine2(field) {
+  const modifier = field.repeated ? "repeated " : field.optional ? "optional " : "";
+  return `${modifier}${field.protoType} ${field.name} = ${field.number};`;
+}
+__name(buildFieldLine2, "buildFieldLine");
+function needsTimestampImport(fields) {
+  return fields.some((f) => f.protoType === "google.protobuf.Timestamp");
+}
+__name(needsTimestampImport, "needsTimestampImport");
+function appendMessageBlock(messageName, fields, lines) {
+  if (fields.length === 0) {
+    throw new Error(`Schema '${messageName}' has no fields \u2014 cannot generate proto. Got 0 fields.`);
+  }
+  lines.push(`message ${messageName} {`);
+  for (const field of fields) {
+    if (field.comment) {
+      lines.push(`  // ${field.comment}`);
+    }
+    lines.push(`  ${buildFieldLine2(field)}`);
+  }
+  lines.push("}", "");
+}
+__name(appendMessageBlock, "appendMessageBlock");
+function fieldsToProto(messageName, fields) {
+  const lines = [
+    'syntax = "proto3";',
+    ""
+  ];
+  if (needsTimestampImport(fields)) {
+    lines.push('import "google/protobuf/timestamp.proto";', "");
+  }
+  appendMessageBlock(messageName, fields, lines);
+  return lines.join("\n").trimEnd();
 }
+__name(fieldsToProto, "fieldsToProto");
 export {
+  fieldsToProto,
   toProto
 };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/generator.ts","../src/fields-to-proto.ts"],"sourcesContent":["/**\n * Generates a proto3 schema string from a decorated class.\n *\n * Reads field metadata from the default SchemaRegistry and produces\n * the exact format the Rust broker expects in the `x-schema` queue argument.\n */\n\nimport { defaultRegistry, type FieldMeta, type Constructor } from '@rocketmq/schema';\n\n/** Forces field registration by instantiating the class once. */\nfunction ensureFieldsRegistered(schema: Constructor): void {\n  if (defaultRegistry.getFields(schema).length > 0) return;\n  try {\n    new schema();\n  } catch {\n    // Constructor may throw — fields are registered via addInitializer\n    void 0;\n  }\n}\n\n/** Recursively collects all schema constructors referenced by the class. */\nfunction collectDependentSchemas(\n  schema: Constructor,\n  seen = new Set<Constructor>(),\n  orderedList: Constructor[] = [],\n): Constructor[] {\n  if (seen.has(schema)) return orderedList;\n  seen.add(schema);\n\n  const fields = defaultRegistry.getFields(schema);\n  for (const field of fields) {\n    if (field.reflectedType && defaultRegistry.isSchema(field.reflectedType)) {\n      collectDependentSchemas(field.reflectedType, seen, orderedList);\n    }\n    if (field.type) {\n      const depSchema = defaultRegistry.getSchemaByName(field.type);\n      if (depSchema) {\n        collectDependentSchemas(depSchema, seen, orderedList);\n      }\n    }\n  }\n  orderedList.push(schema);\n  return orderedList;\n}\n\n/** Determines if any schema in the list uses a Timestamp type. */\nfunction needsTimestamp(schemas: Constructor[]): boolean {\n  return schemas.some((s) =>\n    defaultRegistry.getFields(s).some((f) => f.protoType === 'google.protobuf.Timestamp'),\n  );\n}\n\n/** Builds the protobuf field line using the pre-resolved protoType. */\nfunction buildFieldLine(field: FieldMeta): string {\n  const modifier = field.repeated ? 'repeated ' : field.optional ? 'optional ' : '';\n  return `${modifier}${field.protoType} ${field.name} = ${field.number};`;\n}\n\n/** Formats a schema class as a protobuf message block. */\nfunction buildMessageBlock(schema: Constructor, lines: string[]): void {\n  const fields = defaultRegistry.getFields(schema);\n  if (fields.length === 0) {\n    throw new Error(`Schema '${schema.name}' has no @Field() decorators — cannot generate proto`);\n  }\n  lines.push(`message ${schema.name} {`);\n  for (const field of fields) {\n    if (field.comment) {\n      lines.push(`  // ${field.comment}`);\n    }\n    lines.push(`  ${buildFieldLine(field)}`);\n  }\n  lines.push('}', '');\n}\n\n/** Converts a decorated schema class to a proto3 definition string. */\nexport function toProto(schema: Constructor): string {\n  ensureFieldsRegistered(schema);\n  const orderedList = collectDependentSchemas(schema);\n  if (orderedList.length === 0 || defaultRegistry.getFields(schema).length === 0) {\n    throw new Error(`Schema '${schema.name}' has no @Field() decorators — cannot generate proto`);\n  }\n  const lines: string[] = ['syntax = \"proto3\";', ''];\n  if (needsTimestamp(orderedList)) {\n    lines.push('import \"google/protobuf/timestamp.proto\";', '');\n  }\n  for (const s of orderedList) {\n    buildMessageBlock(s, lines);\n  }\n  return lines.join('\\n').trimEnd();\n}\n","/**\n * Generates proto3 from raw FieldMeta arrays — no class/decorator dependency.\n *\n * This is the shared codegen path used by both the decorator-based `toProto()`\n * and the Zod-based `zodToProto()` pipelines. Factoring it here avoids\n * duplicating proto string assembly logic.\n *\n * Usage:\n *   fieldsToProto('Order', [{ name: 'id', protoType: 'string', number: 1 }]);\n */\n\nimport type { FieldMeta } from '@rocketmq/schema';\n\n/** Builds a single proto3 field line from resolved metadata. */\nfunction buildFieldLine(field: FieldMeta): string {\n  const modifier = field.repeated ? 'repeated ' : field.optional ? 'optional ' : '';\n  return `${modifier}${field.protoType} ${field.name} = ${field.number};`;\n}\n\n/**\n * Checks whether any field in the list needs the Timestamp import.\n *\n * Extracted so callers don't need to know the magic string.\n */\nfunction needsTimestampImport(fields: FieldMeta[]): boolean {\n  return fields.some((f) => f.protoType === 'google.protobuf.Timestamp');\n}\n\n/** Appends one protobuf message block to the output lines array. */\nfunction appendMessageBlock(messageName: string, fields: FieldMeta[], lines: string[]): void {\n  if (fields.length === 0) {\n    throw new Error(`Schema '${messageName}' has no fields — cannot generate proto. Got 0 fields.`);\n  }\n  lines.push(`message ${messageName} {`);\n  for (const field of fields) {\n    if (field.comment) {\n      lines.push(`  // ${field.comment}`);\n    }\n    lines.push(`  ${buildFieldLine(field)}`);\n  }\n  lines.push('}', '');\n}\n\n/**\n * Converts a message name + field metadata list into a proto3 definition.\n *\n * This is the low-level entrypoint — no class introspection, no registry\n * lookups. Works with any source that can produce `FieldMeta[]`.\n *\n * Usage:\n *   const proto = fieldsToProto('Notification', fields);\n *   // => 'syntax = \"proto3\";\\n\\nmessage Notification { ... }'\n */\nexport function fieldsToProto(messageName: string, fields: FieldMeta[]): string {\n  const lines: string[] = ['syntax = \"proto3\";', ''];\n  if (needsTimestampImport(fields)) {\n    lines.push('import \"google/protobuf/timestamp.proto\";', '');\n  }\n  appendMessageBlock(messageName, fields, lines);\n  return lines.join('\\n').trimEnd();\n}\n"],"mappings":"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","names":["defaultRegistry","ensureFieldsRegistered","schema","defaultRegistry","getFields","length","collectDependentSchemas","seen","Set","orderedList","has","add","fields","field","reflectedType","isSchema","type","depSchema","getSchemaByName","push","needsTimestamp","schemas","some","s","f","protoType","buildFieldLine","modifier","repeated","optional","name","number","buildMessageBlock","lines","Error","comment","toProto","join","trimEnd","buildFieldLine","field","modifier","repeated","optional","protoType","name","number","needsTimestampImport","fields","some","f","appendMessageBlock","messageName","lines","length","Error","push","comment","fieldsToProto","join","trimEnd"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rocketmq/protobuf",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "module",
   "exports": {
     ".": {
@@ -9,7 +9,7 @@
     }
   },
   "dependencies": {
-    "@rocketmq/schema": "0.1.0"
+    "@rocketmq/schema": "0.1.2"
   },
   "scripts": {
     "build": "tsup",

package/src/fields-to-proto.test.ts

@@ -0,0 +1,73 @@
+/**
+ * Tests for fieldsToProto() — FieldMeta[] → proto3 string generation.
+ *
+ * This is the shared codegen path used by both decorator and Zod pipelines.
+ */
+
+import { describe, expect, it } from 'vitest';
+import type { FieldMeta } from '@rocketmq/schema';
+import { fieldsToProto } from './fields-to-proto.js';
+
+describe('fieldsToProto', () => {
+  it('generates proto3 from a single field', () => {
+    const fields: FieldMeta[] = [{ name: 'id', protoType: 'string', number: 1 }];
+
+    const expected = ['syntax = "proto3";', '', 'message Order {', '  string id = 1;', '}'].join(
+      '\n',
+    );
+
+    expect(fieldsToProto('Order', fields)).toBe(expected);
+  });
+
+  it('generates proto3 with multiple fields in order', () => {
+    const fields: FieldMeta[] = [
+      { name: 'name', protoType: 'string', number: 1 },
+      { name: 'age', protoType: 'int32', number: 2 },
+      { name: 'active', protoType: 'bool', number: 3 },
+    ];
+
+    const proto = fieldsToProto('Person', fields);
+    expect(proto).toContain('string name = 1;');
+    expect(proto).toContain('int32 age = 2;');
+    expect(proto).toContain('bool active = 3;');
+  });
+
+  it('emits optional modifier', () => {
+    const fields: FieldMeta[] = [
+      { name: 'nickname', protoType: 'string', number: 1, optional: true },
+    ];
+
+    const proto = fieldsToProto('Profile', fields);
+    expect(proto).toContain('optional string nickname = 1;');
+  });
+
+  it('emits repeated modifier', () => {
+    const fields: FieldMeta[] = [{ name: 'tags', protoType: 'string', number: 1, repeated: true }];
+
+    const proto = fieldsToProto('Item', fields);
+    expect(proto).toContain('repeated string tags = 1;');
+  });
+
+  it('emits comment above field', () => {
+    const fields: FieldMeta[] = [
+      { name: 'score', protoType: 'double', number: 1, comment: 'Player score' },
+    ];
+
+    const proto = fieldsToProto('Game', fields);
+    expect(proto).toContain('// Player score');
+    expect(proto).toContain('double score = 1;');
+  });
+
+  it('includes Timestamp import when needed', () => {
+    const fields: FieldMeta[] = [
+      { name: 'createdAt', protoType: 'google.protobuf.Timestamp', number: 1 },
+    ];
+
+    const proto = fieldsToProto('Event', fields);
+    expect(proto).toContain('import "google/protobuf/timestamp.proto";');
+  });
+
+  it('throws for empty fields array', () => {
+    expect(() => fieldsToProto('Empty', [])).toThrow("Schema 'Empty' has no fields");
+  });
+});

package/src/fields-to-proto.ts

@@ -0,0 +1,61 @@
+/**
+ * Generates proto3 from raw FieldMeta arrays — no class/decorator dependency.
+ *
+ * This is the shared codegen path used by both the decorator-based `toProto()`
+ * and the Zod-based `zodToProto()` pipelines. Factoring it here avoids
+ * duplicating proto string assembly logic.
+ *
+ * Usage:
+ *   fieldsToProto('Order', [{ name: 'id', protoType: 'string', number: 1 }]);
+ */
+
+import type { FieldMeta } from '@rocketmq/schema';
+
+/** Builds a single proto3 field line from resolved metadata. */
+function buildFieldLine(field: FieldMeta): string {
+  const modifier = field.repeated ? 'repeated ' : field.optional ? 'optional ' : '';
+  return `${modifier}${field.protoType} ${field.name} = ${field.number};`;
+}
+
+/**
+ * Checks whether any field in the list needs the Timestamp import.
+ *
+ * Extracted so callers don't need to know the magic string.
+ */
+function needsTimestampImport(fields: FieldMeta[]): boolean {
+  return fields.some((f) => f.protoType === 'google.protobuf.Timestamp');
+}
+
+/** Appends one protobuf message block to the output lines array. */
+function appendMessageBlock(messageName: string, fields: FieldMeta[], lines: string[]): void {
+  if (fields.length === 0) {
+    throw new Error(`Schema '${messageName}' has no fields — cannot generate proto. Got 0 fields.`);
+  }
+  lines.push(`message ${messageName} {`);
+  for (const field of fields) {
+    if (field.comment) {
+      lines.push(`  // ${field.comment}`);
+    }
+    lines.push(`  ${buildFieldLine(field)}`);
+  }
+  lines.push('}', '');
+}
+
+/**
+ * Converts a message name + field metadata list into a proto3 definition.
+ *
+ * This is the low-level entrypoint — no class introspection, no registry
+ * lookups. Works with any source that can produce `FieldMeta[]`.
+ *
+ * Usage:
+ *   const proto = fieldsToProto('Notification', fields);
+ *   // => 'syntax = "proto3";\n\nmessage Notification { ... }'
+ */
+export function fieldsToProto(messageName: string, fields: FieldMeta[]): string {
+  const lines: string[] = ['syntax = "proto3";', ''];
+  if (needsTimestampImport(fields)) {
+    lines.push('import "google/protobuf/timestamp.proto";', '');
+  }
+  appendMessageBlock(messageName, fields, lines);
+  return lines.join('\n').trimEnd();
+}

package/src/generator.test.ts

@@ -1,45 +1,54 @@
 /**
  * Tests for toProto() — proto3 string generation.
- *
- * Covers: valid schemas, empty schemas (error), multi-field ordering,
- * and the force-instantiation path for uninitialized classes.
  */
 
-import { describe, it, expect } from 'vitest';
-import { toProto } from './generator.js';
+import { describe, expect, it } from 'vitest';
 import { Schema, Field, defaultRegistry } from '@rocketmq/schema';
+import { toProto } from './generator.js';
 
 describe('toProto', () => {
   it('generates proto3 string for a single-field class', () => {
     @Schema()
     class SingleField {
       @Field()
-      id!: string;
+      id = '';
     }
     new SingleField();
 
-    const proto = toProto(SingleField);
-    expect(proto).toBe('syntax = "proto3"; message SingleField { string id = 1; }');
+    const expected = [
+      'syntax = "proto3";',
+      '',
+      'message SingleField {',
+      '  string id = 1;',
+      '}',
+    ].join('\n');
+    expect(toProto(SingleField)).toBe(expected);
   });
 
   it('generates proto3 with multiple fields in order', () => {
     @Schema()
     class MultiField {
       @Field()
-      name!: string;
+      name = '';
 
       @Field({ type: 'int32' })
-      age!: number;
+      age = 0;
 
       @Field({ type: 'bool' })
-      active!: boolean;
+      active = false;
     }
     new MultiField();
 
-    const proto = toProto(MultiField);
-    expect(proto).toBe(
-      'syntax = "proto3"; message MultiField { string name = 1; int32 age = 2; bool active = 3; }',
-    );
+    const expected = [
+      'syntax = "proto3";',
+      '',
+      'message MultiField {',
+      '  string name = 1;',
+      '  int32 age = 2;',
+      '  bool active = 3;',
+      '}',
+    ].join('\n');
+    expect(toProto(MultiField)).toBe(expected);
   });
 
   it('throws for class with no @Field() decorators', () => {
@@ -52,40 +61,133 @@ describe('toProto', () => {
   });
 
   it('forces instantiation when fields are not yet registered', () => {
-    // Simulate a class that hasn't been instantiated yet
     @Schema()
     class LazyInit {
       @Field()
-      value!: string;
+      value = '';
     }
-    // Do NOT call `new LazyInit()` — toProto should do it internally
-    const proto = toProto(LazyInit);
-    expect(proto).toContain('string value = 1');
+    expect(toProto(LazyInit)).toContain('string value = 1;');
   });
 
   it('handles class whose constructor throws', () => {
-    // WHY: toProto wraps instantiation in try/catch for classes
-    // that require constructor arguments
     class ThrowingCtor {
       @Field()
-      x!: string;
+      x = '';
 
       constructor() {
-        // Fields registered via addInitializer before the throw
         throw new Error('required args');
       }
     }
-    // Force-register the field store entry
     defaultRegistry.getOrCreateFields(ThrowingCtor);
 
-    // toProto will try `new ThrowingCtor()`, catch, and check fields
-    // Since addInitializer runs before constructor body, field might be registered
-    // If not, it should throw "no @Field() decorators"
     try {
-      const proto = toProto(ThrowingCtor);
-      expect(proto).toContain('string x = 1');
+      expect(toProto(ThrowingCtor)).toContain('string x = 1;');
     } catch (err) {
       expect((err as Error).message).toContain('no @Field() decorators');
     }
   });
+
+  it('generates optional, repeated, and commented fields', () => {
+    @Schema()
+    class CustomField {
+      @Field({ type: 'string', repeated: true })
+      tags: string[] = [];
+
+      @Field({ type: 'string', optional: true })
+      nickname?: string;
+
+      @Field({ type: 'double', comment: 'User age in years' })
+      age!: number;
+    }
+    new CustomField();
+
+    const proto = toProto(CustomField);
+    expect(proto).toContain('repeated string tags = 1;');
+    expect(proto).toContain('optional string nickname = 2;');
+    expect(proto).toContain('// User age in years');
+    expect(proto).toContain('double age = 3;');
+  });
+
+  it('handles Date as Timestamp with imports', () => {
+    @Schema()
+    class TimeField {
+      @Field({ type: 'google.protobuf.Timestamp' })
+      createdAt = new Date();
+    }
+    new TimeField();
+
+    const proto = toProto(TimeField);
+    expect(proto).toContain('import "google/protobuf/timestamp.proto";');
+    expect(proto).toContain('google.protobuf.Timestamp createdAt = 1;');
+  });
+
+  it('handles nested schemas and orders them correctly', () => {
+    @Schema()
+    class Child {
+      @Field()
+      name = '';
+    }
+    @Schema()
+    class Parent {
+      @Field({ type: 'Child' })
+      child = new Child();
+    }
+    new Child();
+    new Parent();
+
+    const proto = toProto(Parent);
+    expect(proto).toContain('message Child {');
+    expect(proto).toContain('message Parent {');
+    expect(proto.indexOf('message Child {')).toBeLessThan(proto.indexOf('message Parent {'));
+  });
+
+  describe('edge cases', () => {
+    it('handles constructors that throw', () => {
+      @Schema()
+      class ThrowingClass {
+        @Field()
+        id!: string;
+        constructor() {
+          throw new Error('fail');
+        }
+      }
+      const proto = toProto(ThrowingClass);
+      expect(proto).toContain('message ThrowingClass');
+    });
+
+    it('throws if dependent schema has no fields', () => {
+      @Schema()
+      class NoFieldsDep {}
+
+      @Schema()
+      class DependentParent {
+        @Field({ type: 'NoFieldsDep' })
+        child!: NoFieldsDep;
+      }
+      // manually register to ensure lookup works
+      defaultRegistry.registerSchema(NoFieldsDep);
+
+      expect(() => toProto(DependentParent)).toThrow(/no @Field/);
+    });
+
+    it('collects nested schemas via reflect metadata type', () => {
+      @Schema()
+      class NestedReflectChild {
+        @Field()
+        id!: string;
+      }
+
+      @Schema()
+      class ReflectParent {
+        @Field({ type: 'NestedReflectChild' })
+        child!: NestedReflectChild;
+      }
+      // Force reflectedType manually since we don't emit it fully in vitest by default
+      defaultRegistry.getOrCreateFields(ReflectParent)[0].reflectedType = NestedReflectChild;
+
+      const proto = toProto(ReflectParent);
+      expect(proto).toContain('message NestedReflectChild');
+      expect(proto).toContain('message ReflectParent');
+    });
+  });
 });

package/src/generator.ts

@@ -3,45 +3,88 @@
  *
  * Reads field metadata from the default SchemaRegistry and produces
  * the exact format the Rust broker expects in the `x-schema` queue argument.
- *
- * Usage:
- *   const proto = toProto(NotificationClass);
- *   // => 'syntax = "proto3"; message Notification { string id = 1; int64 timestamp = 2; }'
  */
 
-import { defaultRegistry } from '@rocketmq/schema';
+import { defaultRegistry, type FieldMeta, type Constructor } from '@rocketmq/schema';
 
-/**
- * Forces field registration by instantiating the class once.
- *
- * TC39 field decorators defer registration via `addInitializer`,
- * which only runs on construction. If no instance exists yet,
- * the registry will have zero fields for the class.
- */
-function ensureFieldsRegistered(schema: Function): void {
+/** Forces field registration by instantiating the class once. */
+function ensureFieldsRegistered(schema: Constructor): void {
   if (defaultRegistry.getFields(schema).length > 0) return;
-
   try {
-    new (schema as new () => unknown)();
+    new schema();
   } catch {
     // Constructor may throw — fields are registered via addInitializer
+    void 0;
   }
 }
 
-/**
- * Converts a decorated schema class to a proto3 definition string.
- *
- * @throws Error if the class has no @Field() decorators.
- */
-export function toProto(schema: Function): string {
-  ensureFieldsRegistered(schema);
+/** Recursively collects all schema constructors referenced by the class. */
+function collectDependentSchemas(
+  schema: Constructor,
+  seen = new Set<Constructor>(),
+  orderedList: Constructor[] = [],
+): Constructor[] {
+  if (seen.has(schema)) return orderedList;
+  seen.add(schema);
 
+  const fields = defaultRegistry.getFields(schema);
+  for (const field of fields) {
+    if (field.reflectedType && defaultRegistry.isSchema(field.reflectedType)) {
+      collectDependentSchemas(field.reflectedType, seen, orderedList);
+    }
+    if (field.type) {
+      const depSchema = defaultRegistry.getSchemaByName(field.type);
+      if (depSchema) {
+        collectDependentSchemas(depSchema, seen, orderedList);
+      }
+    }
+  }
+  orderedList.push(schema);
+  return orderedList;
+}
+
+/** Determines if any schema in the list uses a Timestamp type. */
+function needsTimestamp(schemas: Constructor[]): boolean {
+  return schemas.some((s) =>
+    defaultRegistry.getFields(s).some((f) => f.protoType === 'google.protobuf.Timestamp'),
+  );
+}
+
+/** Builds the protobuf field line using the pre-resolved protoType. */
+function buildFieldLine(field: FieldMeta): string {
+  const modifier = field.repeated ? 'repeated ' : field.optional ? 'optional ' : '';
+  return `${modifier}${field.protoType} ${field.name} = ${field.number};`;
+}
+
+/** Formats a schema class as a protobuf message block. */
+function buildMessageBlock(schema: Constructor, lines: string[]): void {
   const fields = defaultRegistry.getFields(schema);
   if (fields.length === 0) {
     throw new Error(`Schema '${schema.name}' has no @Field() decorators — cannot generate proto`);
   }
+  lines.push(`message ${schema.name} {`);
+  for (const field of fields) {
+    if (field.comment) {
+      lines.push(`  // ${field.comment}`);
+    }
+    lines.push(`  ${buildFieldLine(field)}`);
+  }
+  lines.push('}', '');
+}
 
-  const body = fields.map((f) => `${f.protoType} ${f.name} = ${f.number};`).join(' ');
-
-  return `syntax = "proto3"; message ${schema.name} { ${body} }`;
+/** Converts a decorated schema class to a proto3 definition string. */
+export function toProto(schema: Constructor): string {
+  ensureFieldsRegistered(schema);
+  const orderedList = collectDependentSchemas(schema);
+  if (orderedList.length === 0 || defaultRegistry.getFields(schema).length === 0) {
+    throw new Error(`Schema '${schema.name}' has no @Field() decorators — cannot generate proto`);
+  }
+  const lines: string[] = ['syntax = "proto3";', ''];
+  if (needsTimestamp(orderedList)) {
+    lines.push('import "google/protobuf/timestamp.proto";', '');
+  }
+  for (const s of orderedList) {
+    buildMessageBlock(s, lines);
+  }
+  return lines.join('\n').trimEnd();
 }

package/src/index.ts

@@ -1 +1,2 @@
 export { toProto } from './generator.js';
+export { fieldsToProto } from './fields-to-proto.js';

package/tsup.config.ts

@@ -5,4 +5,5 @@ export default defineConfig({
   format: ["esm", "cjs"],
   dts: true,
   clean: true,
+  sourcemap: true,
 });