@rocketmq/protobuf 0.1.0

package/.turbo/turbo-build.log

@@ -0,0 +1,21 @@
+
+
+> @rocketmq/protobuf@0.1.0 build /home/edilson/learnspace/rocketmq-broker/client-ts/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 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
+DTS Build start
+DTS ⚡️ Build success in 896ms
+DTS dist/index.d.ts  581.00 B
+DTS dist/index.d.cts 581.00 B

package/dist/index.cjs

@@ -0,0 +1,48 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  toProto: () => toProto
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/generator.ts
+var import_schema = require("@rocketmq/schema");
+function ensureFieldsRegistered(schema) {
+  if (import_schema.defaultRegistry.getFields(schema).length > 0) return;
+  try {
+    new schema();
+  } catch {
+  }
+}
+function toProto(schema) {
+  ensureFieldsRegistered(schema);
+  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} }`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  toProto
+});

package/dist/index.d.cts

@@ -0,0 +1,18 @@
+/**
+ * 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.
+ *
+ * Usage:
+ *   const proto = toProto(NotificationClass);
+ *   // => 'syntax = "proto3"; message Notification { string id = 1; int64 timestamp = 2; }'
+ */
+/**
+ * Converts a decorated schema class to a proto3 definition string.
+ *
+ * @throws Error if the class has no @Field() decorators.
+ */
+declare function toProto(schema: Function): string;
+
+export { toProto };

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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.
+ *
+ * Usage:
+ *   const proto = toProto(NotificationClass);
+ *   // => 'syntax = "proto3"; message Notification { string id = 1; int64 timestamp = 2; }'
+ */
+/**
+ * Converts a decorated schema class to a proto3 definition string.
+ *
+ * @throws Error if the class has no @Field() decorators.
+ */
+declare function toProto(schema: Function): string;
+
+export { toProto };

package/dist/index.js

@@ -0,0 +1,21 @@
+// src/generator.ts
+import { defaultRegistry } from "@rocketmq/schema";
+function ensureFieldsRegistered(schema) {
+  if (defaultRegistry.getFields(schema).length > 0) return;
+  try {
+    new schema();
+  } catch {
+  }
+}
+function toProto(schema) {
+  ensureFieldsRegistered(schema);
+  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} }`;
+}
+export {
+  toProto
+};

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@rocketmq/protobuf",
+  "version": "0.1.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "dependencies": {
+    "@rocketmq/schema": "0.1.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run"
+  }
+}

package/src/generator.test.ts

@@ -0,0 +1,91 @@
+/**
+ * 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 { Schema, Field, defaultRegistry } from '@rocketmq/schema';
+
+describe('toProto', () => {
+  it('generates proto3 string for a single-field class', () => {
+    @Schema()
+    class SingleField {
+      @Field()
+      id!: string;
+    }
+    new SingleField();
+
+    const proto = toProto(SingleField);
+    expect(proto).toBe('syntax = "proto3"; message SingleField { string id = 1; }');
+  });
+
+  it('generates proto3 with multiple fields in order', () => {
+    @Schema()
+    class MultiField {
+      @Field()
+      name!: string;
+
+      @Field({ type: 'int32' })
+      age!: number;
+
+      @Field({ type: 'bool' })
+      active!: boolean;
+    }
+    new MultiField();
+
+    const proto = toProto(MultiField);
+    expect(proto).toBe(
+      'syntax = "proto3"; message MultiField { string name = 1; int32 age = 2; bool active = 3; }',
+    );
+  });
+
+  it('throws for class with no @Field() decorators', () => {
+    @Schema()
+    class NoFields {}
+
+    expect(() => toProto(NoFields)).toThrow(
+      "Schema 'NoFields' has no @Field() decorators — cannot generate proto",
+    );
+  });
+
+  it('forces instantiation when fields are not yet registered', () => {
+    // Simulate a class that hasn't been instantiated yet
+    @Schema()
+    class LazyInit {
+      @Field()
+      value!: string;
+    }
+    // Do NOT call `new LazyInit()` — toProto should do it internally
+    const proto = toProto(LazyInit);
+    expect(proto).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;
+
+      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');
+    } catch (err) {
+      expect((err as Error).message).toContain('no @Field() decorators');
+    }
+  });
+});

package/src/generator.ts

@@ -0,0 +1,47 @@
+/**
+ * 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.
+ *
+ * Usage:
+ *   const proto = toProto(NotificationClass);
+ *   // => 'syntax = "proto3"; message Notification { string id = 1; int64 timestamp = 2; }'
+ */
+
+import { defaultRegistry } 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 {
+  if (defaultRegistry.getFields(schema).length > 0) return;
+
+  try {
+    new (schema as new () => unknown)();
+  } catch {
+    // Constructor may throw — fields are registered via addInitializer
+  }
+}
+
+/**
+ * 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);
+
+  const fields = defaultRegistry.getFields(schema);
+  if (fields.length === 0) {
+    throw new Error(`Schema '${schema.name}' has no @Field() decorators — cannot generate proto`);
+  }
+
+  const body = fields.map((f) => `${f.protoType} ${f.name} = ${f.number};`).join(' ');
+
+  return `syntax = "proto3"; message ${schema.name} { ${body} }`;
+}

package/src/index.ts

@@ -0,0 +1 @@
+export { toProto } from './generator.js';

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src"]
+}

package/tsup.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  entry: ["src/index.ts"],
+  format: ["esm", "cjs"],
+  dts: true,
+  clean: true,
+});