neoproto 0.0.1

package/.github/workflows/npm-publish.yml

@@ -0,0 +1,23 @@
+# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
+# For more information see: https://docs.github.com/en/actions/publishing-packages/publishing-nodejs-packages
+
+name: Node.js Package
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  npm-publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          registry-url: https://registry.npmjs.org/
+      - run: npm ci
+      - run: npm test
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.npm_token}}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kollin Murphy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,21 @@
+# neoproto
+
+`neoproto` is a code generation tool that focuses on improving the developer experience of working with protobuf messages in TypeScript. It generates usable type definitions, serialization and deserialization functions, and test cases for protobuf messages defined in `.proto` files. The goal is to produce an idiomatic TypeScript API that abstracts away the idiosyncrasies of protobuf as much as possible.
+
+### Limitations
+
+This is a strongly opinionated library that makes certain assumptions about how protobuf messages are defined and used. It is not a general-purpose library. You may find it helpful, or you may find that it does not fit your use case. In either case, please feel free to fork the library and modify it to suit your needs.
+
+This project supports only a subset of the `proto2` syntax (messages and enums). `proto3` is not supported.
+
+As defined in the [protobuf spec version 2](https://protobuf.dev/programming-guides/proto2/#default), the default values of fields are as follows:
+
+| Type          | Default Value |
+| ------------- | ------------- |
+| string        | empty string  |
+| bytes         | empty bytes   |
+| bool          | false         |
+| numeric types | zero          |
+| enum          | first value   |
+
+Given the above, there is no way to differentiate between a field that is set to its default value and a field that is not set at all. This can lead to ambiguity in certain cases, especially when dealing with optional fields. This library has taken the approach of treating all optional fields as if they were set to the default value. Ensure that your protobuf messages are designed with this in mind to avoid unintended consequences, and that usage of the library aligns with this behavior.

package/data/enum.proto

@@ -0,0 +1,36 @@
+syntax = "proto2";
+
+package My_Enum_ApiV2;
+
+/** This is an example of an enum definition in Protocol Buffers. */
+enum Corpus {
+  CORPUS_UNSPECIFIED = 0;
+  CORPUS_UNIVERSAL = 1;
+  CORPUS_WEB = 2;
+  CORPUS_IMAGES = 3;
+  CORPUS_LOCAL = 4;
+  CORPUS_NEWS = 5;
+  CORPUS_PRODUCTS = 6;
+  CORPUS_VIDEO = 7;
+}
+
+/* MessageId: 3 */
+message SearchRequest {
+
+  message Nested {
+    required int32 id = 1;
+    required string name = 2;
+  }
+
+  optional string query = 1;
+  optional int32 page_number = 2;
+  optional int32 results_per_page = 3;
+  required Corpus corpus1 = 4;
+  required Corpus corpus2 = 5;
+  required Nested nested = 6;
+}
+
+/* MessageId: 4 */
+message SearchResponse {
+  required string results = 1;
+}

package/data/example.proto

@@ -0,0 +1,42 @@
+// Text 1
+syntax = "proto2";
+
+// Text 2
+
+/* Test 439104 */
+package My_Api_V1;
+
+message MyNestedMessage {
+  required int32 id = 1;
+  required int64 some_other_long = 2;
+}
+
+/* A simple message for demonstration purposes.
+    This is a continuation.
+    * More stuff
+  * MessageId: 1
+*/
+message MyMessageReq {
+  /* Text 3 */
+ required string value = 1;
+ optional int64 some_long = 2;
+ optional MyNestedMessage nested = 3;
+ required bool some_thing = 4;
+ repeated string some_repeated_string = 5;
+ repeated MyNestedMessage some_repeated_nested = 6;
+}
+
+/**
+  * This is a response message for MyMessageReq.
+  * It contains the same fields as MyMessageReq, but it is a separate message type.
+  * MessageId: 2
+  */
+message MyMessageRes {
+  required string value = 1;
+  optional int64 some_long = 2;
+  optional MyNestedMessage nested = 3;
+  required bool some_thing = 4;
+  repeated string some_repeated_string = 5;
+  repeated MyNestedMessage some_repeated_nested = 6;
+  required bytes binary_data = 7;
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "neoproto",
+  "version": "0.0.1",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kollinmurphy/neoproto.git"
+  },
+  "description": "An opinionated wrapper around the Protobuf TypeScript compiler that generates idiomatic types, serialization functions, and documentation.",
+  "main": "src/index.ts",
+  "type": "module",
+  "scripts": {
+    "start": "tsx src/index.ts",
+    "postinstall": "patch-package"
+  },
+  "keywords": [
+    "protobuf",
+    "typescript",
+    "codegen",
+    "serialization",
+    "deserialization"
+  ],
+  "author": "Kollin Murphy",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^25.2.3",
+    "patch-package": "^8.0.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "long": "^5.3.2",
+    "prettier": "^3.8.1",
+    "protobufjs": "^7.5.4",
+    "protobufjs-cli": "^2.0.0"
+  }
+}

package/patches/protobufjs-cli+2.0.0.patch

@@ -0,0 +1,10 @@
+diff --git a/node_modules/protobufjs-cli/wrappers/es6.js b/node_modules/protobufjs-cli/wrappers/es6.js
+index 5bdc43c..33246d7 100644
+--- a/node_modules/protobufjs-cli/wrappers/es6.js
++++ b/node_modules/protobufjs-cli/wrappers/es6.js
+@@ -1,4 +1,4 @@
+-import * as $protobuf from $DEPENDENCY;
++import $protobuf from $DEPENDENCY;
+ 
+ $OUTPUT;
+ 

package/src/generators/serialization.ts

@@ -0,0 +1,129 @@
+import proto from "protobufjs";
+import { capitalizeFirstLetter } from "../utils/string-manipulation.js";
+import { getWrapperFunctionName } from "./wrap.js";
+import { getUnwrapperFunctionName } from "./unwrap.js";
+import { getMessages } from "../utils/protobuf.js";
+import { getMessageId } from "../utils/associations.js";
+import { logError } from "../utils/logger.js";
+
+/**
+ * Generates wrapper functions for all messages and enums in a protobuf namespace, including nested namespaces, and returns the content of the wrapper file as a string.
+ * @param namespace - The protobuf namespace to create wrapper functions for
+ * @returns A string containing the content of the wrapper file with all the generated wrapper functions for the protobuf namespace
+ */
+function createNamespaceSerializers(namespace: proto.Namespace): string {
+  let definitions = "";
+  const exports: string[] = [];
+  const typeImports: string[] = [];
+  const wrapperImports: string[] = [];
+  const unwrapperImports: string[] = [];
+  const messages = getMessages(namespace);
+  for (const message of messages) {
+    if (!getMessageId(message)) continue;
+    const {
+      definitions: messageDefinitions,
+      exports: messageExports,
+      typeImports: messageImports,
+      wrapperImports: messageWrapperImports,
+      unwrapperImports: messageUnwrapperImports,
+    } = createMessageSerializers(namespace.name, message);
+    definitions += messageDefinitions;
+    exports.push(...messageExports);
+    typeImports.push(...messageImports);
+    wrapperImports.push(...messageWrapperImports);
+    unwrapperImports.push(...messageUnwrapperImports);
+  }
+
+  if (!definitions)
+    logError(
+      `No messages with a valid message ID found in namespace ${namespace.name}.`,
+    );
+
+  const dedupedTypeImports = [...new Set(typeImports)];
+  const dedupedWrapperImports = [...new Set(wrapperImports)];
+  const dedupedUnwrapperImports = [...new Set(unwrapperImports)];
+  return `import type { ${dedupedTypeImports.join(", ")} } from "./types.js";
+import { ${namespace.name} } from "./protobuf/${namespace.name}.js";
+import { ${dedupedWrapperImports.join(", ")} } from "./wrap.js";
+import { ${dedupedUnwrapperImports.join(", ")} } from "./unwrap.js";
+${definitions}
+export {
+  ${exports.join(",\n  ")},
+};
+`;
+}
+
+/**
+ * Generates a serializer and deserializer function for a single protobuf message type. The serializer function takes an instance of the message type and returns a Uint8Array containing the serialized message, while the deserializer function takes a Uint8Array containing the serialized message and returns an instance of the message type. The functions use the protobufjs library to perform the encoding and decoding, and they also utilize wrapper and unwrapper functions to convert between the protobuf message format and the TypeScript types defined for the message.
+ * @param namespace - The name of the protobuf namespace that the message type belongs to, which is used to reference the correct message type in the protobufjs encoding and decoding functions
+ * @param message - The protobuf message type to create the serializer and deserializer functions for
+ * @returns An object containing the TypeScript definitions for the serializer and deserializer functions, the names of the functions to be exported, and arrays of imports required for the message types and wrapper/unwrapper functions used in the definitions
+ */
+function createMessageSerializers(
+  namespace: string,
+  message: proto.Type,
+): {
+  definitions: string;
+  exports: string[];
+  typeImports: string[];
+  wrapperImports: string[];
+  unwrapperImports: string[];
+} {
+  const functionSuffix = capitalizeFirstLetter(message.name);
+
+  const serialize = `serialize${functionSuffix}`;
+  const deserialize = `deserialize${functionSuffix}`;
+  const wrap = getWrapperFunctionName(message.name);
+  const unwrap = getUnwrapperFunctionName(message.name);
+
+  const definitions = `
+/**
+ * Serializes a ${message.name} message to a Uint8Array.
+ * @param input ${message.name} message to serialize
+ * @returns Uint8Array containing the serialized message
+ */
+function ${serialize}(input: ${message.name}): Uint8Array {
+  return ${namespace}.${message.name}.encode(${unwrap}(input)).finish();
+}
+
+/**
+ * Deserializes a ${message.name} message from a Uint8Array.
+ * @param input Uint8Array containing the serialized message
+ * @returns ${message.name} message
+ */
+function ${deserialize}(input: Uint8Array): ${message.name} {
+  return ${wrap}(${namespace}.${message.name}.decode(input));
+}
+`;
+  return {
+    definitions,
+    exports: [serialize, deserialize],
+    typeImports: [message.name],
+    wrapperImports: [wrap],
+    unwrapperImports: [unwrap],
+  };
+}
+
+/**
+ * Generates a serializer and deserializer function name for a given protobuf message name by capitalizing the first letter of the message name and prefixing it with "serialize" for the serializer function and "deserialize" for the deserializer function. For example, if the message name is "MyMessage", the generated serializer function name would be "serializeMyMessage" and the deserializer function name would be "deserializeMyMessage".
+ * @param messageName - The name of the protobuf message type to generate the serializer and deserializer function names for
+ * @returns An object containing the generated serializer and deserializer function names for the specified protobuf message type
+ */
+function getSerializerFunctionName(messageName: string) {
+  return `serialize${capitalizeFirstLetter(messageName)}`;
+}
+
+/**
+ * Generates a deserializer function name for a given protobuf message name by capitalizing the first letter of the message name and prefixing it with "deserialize". For example, if the message name is "MyMessage", the generated deserializer function name would be "deserializeMyMessage".
+ * @param messageName - The name of the protobuf message type to generate the deserializer function name for
+ * @returns A string containing the generated deserializer function name for the specified protobuf message type
+ */
+function getDeserializerFunctionName(messageName: string) {
+  return `deserialize${capitalizeFirstLetter(messageName)}`;
+}
+
+export {
+  createNamespaceSerializers,
+  getSerializerFunctionName,
+  getDeserializerFunctionName,
+};

package/src/generators/test.ts

@@ -0,0 +1,206 @@
+import proto from "protobufjs";
+import {
+  getMessages,
+  hasOptionalField,
+  isRequiredField,
+} from "../utils/protobuf.js";
+import { getMessageId } from "../utils/associations.js";
+import {
+  getDeserializerFunctionName,
+  getSerializerFunctionName,
+} from "./serialization.js";
+import { logError } from "../utils/logger.js";
+
+/**
+ * Defines the behavior for handling optional fields when creating test
+ * instances for protobuf messages. The "all-required" behavior includes all
+ * fields as required, the "omit-optional" behavior omits optional fields from
+ * the test instance, and the "default-optional" behavior includes optional
+ * fields with default values (e.g., empty string for strings, 0 for numbers,
+ * false for booleans). This type is used to specify how optional fields should
+ * be treated when generating test cases for protobuf messages in the generated
+ * test file.
+ */
+type OptionalBehavior = "all-required" | "omit-optional" | "default-optional";
+
+/**
+ * Generates test cases for all messages in a protobuf namespace, including nested namespaces, and returns the content of the test file as a string. The generated tests include serialization and deserialization tests for each message, as well as additional tests for handling optional fields if any are present in the message definitions.
+ * @param namespace - The protobuf namespace to create test cases for
+ * @param relativePath - The relative path to the generated index file for the protobuf namespace, which is used for importing the serializer and deserializer functions in the generated test file
+ * @returns A string containing the content of the test file with all the generated test cases for the protobuf namespace
+ */
+function generateNamespaceTests(
+  namespace: proto.Namespace,
+  relativePath: string,
+) {
+  const messages = getMessages(namespace).filter((msg) =>
+    Boolean(getMessageId(msg)),
+  );
+
+  return `
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { ${messages
+    .flatMap((msg) => [
+      getSerializerFunctionName(msg.name),
+      getDeserializerFunctionName(msg.name),
+      `type ${msg.name}`,
+    ])
+    .join(", ")} } from "${relativePath}/index.js";
+
+describe("${namespace.name}", () => {
+  ${messages.map((msg) => generateMessageTests(msg)).join("\n")}
+});
+
+`;
+}
+
+/**
+ * Generates test cases for a single protobuf message type, including serialization and deserialization tests, as well as additional tests for handling optional fields if any are present in the message definition. The generated tests create instances of the message with different combinations of required and optional fields to ensure that the serializer and deserializer functions handle all cases correctly.
+ * @param message - The protobuf message type to create test cases for
+ * @returns A string containing the test cases for the specified protobuf message type, including serialization and deserialization tests and optional field handling tests if applicable
+ */
+function generateMessageTests(message: proto.Type): string {
+  const serializer = getSerializerFunctionName(message.name);
+  const deserializer = getDeserializerFunctionName(message.name);
+  const optional = hasOptionalField(message);
+  const optionalTest = optional
+    ? `it("should handle optional fields correctly", () => {
+    const original: ${message.name} = ${createTestInstance(message, "omit-optional")};
+    const defaulted: ${message.name} = ${createTestInstance(message, "default-optional")};
+    const serialized = ${serializer}(original);
+    const deserialized = ${deserializer}(serialized);
+    assert.deepStrictEqual(deserialized, defaulted);
+  });`
+    : "";
+  return `
+describe("${message.name}", () => {
+  it("should serialize and deserialize correctly", () => {
+    const original: ${message.name} = ${createTestInstance(message, "all-required")};
+    const serialized = ${serializer}(original);
+    const deserialized = ${deserializer}(serialized);
+    assert.deepStrictEqual(deserialized, original);
+  });
+  ${optionalTest}
+});
+`;
+}
+
+/**
+ * Creates a test instance of a protobuf message type with example values for each field, handling optional fields according to the specified behavior. The function generates a string representation of a TypeScript object that can be used as a test instance for the message type in serialization and deserialization tests. For repeated fields, it generates an array of example values, and for optional fields, it either omits them or sets them to default values based on the provided optional behavior.
+ * @param message - The protobuf message type to create a test instance for
+ * @param optionalBehavior - The behavior to apply for optional fields when creating the test instance, which can be "all-required" to include all fields as required, "omit-optional" to omit optional fields from the test instance, or "default-optional" to include optional fields with default values (e.g., empty string for strings, 0 for numbers, false for booleans)
+ * @returns A string containing the TypeScript object representation of a test instance for the specified protobuf message type, with example values for each field and handling of optional fields according to the specified behavior
+ */
+function createTestInstance(
+  message: proto.Type,
+  optionalBehavior: OptionalBehavior,
+): string {
+  return `{
+${message.fieldsArray
+  .map((field) => createTestFieldValue(field, optionalBehavior))
+  .filter(Boolean)
+  .join("\n")}
+    }`;
+}
+
+/**
+ * Creates a test value for a single field of a protobuf message type, handling optional fields according to the specified behavior. The function generates a string representation of the field assignment that can be included in a test instance for the message type. For repeated fields, it generates an array of example values, and for optional fields, it either omits them or sets them to default values based on the provided optional behavior.
+ * @param field - The protobuf field to create a test value for
+ * @param optionalBehavior - The behavior to apply for optional fields when creating the test value, which can be "all-required" to include all fields as required, "omit-optional" to omit optional fields from the test value, or "default-optional" to include optional fields with default values (e.g., empty string for strings, 0 for numbers, false for booleans)
+ * @param omitFieldName - A boolean flag indicating whether to omit the field name in the generated test value, which is used for generating values for repeated fields where the field name is not included in the array elements
+ * @returns A string containing the TypeScript representation of the test value for the specified protobuf field, with handling of optional fields according to the specified behavior. If the field is omitted due to being optional and the optional behavior is "omit-optional", it returns null.
+ */
+function createTestFieldValue(
+  field: proto.Field,
+  optionalBehavior: OptionalBehavior,
+  omitFieldName = false,
+): string | null {
+  const isOptional = !isRequiredField(field);
+  if (optionalBehavior === "omit-optional" && isOptional && !field.repeated) {
+    return null; // Skip optional fields if optionalBehavior is "omit-optional"
+  }
+
+  const fieldName = field.name;
+  const fieldType = field.resolvedType ? field.resolvedType.name : field.type;
+  let exampleValue: string;
+
+  if (field.repeated) {
+    if (optionalBehavior === "all-required") {
+      const instance = createTestFieldValue(
+        { ...field, repeated: false } as proto.Field,
+        optionalBehavior,
+        /* omitFieldName */ true,
+      );
+      exampleValue = `[${instance}, ${instance}]`;
+    } else {
+      exampleValue = "[]"; // Use empty array for repeated fields when omitting optional fields
+    }
+  } else {
+    switch (fieldType) {
+      case "string":
+        exampleValue =
+          optionalBehavior === "default-optional" && isOptional
+            ? `""`
+            : `"example"`;
+        break;
+      case "int32":
+      case "uint32":
+      case "sint32":
+      case "fixed32":
+      case "sfixed32":
+        exampleValue =
+          optionalBehavior === "default-optional" && isOptional ? `0` : `123`;
+        break;
+      case "int64":
+      case "uint64":
+      case "sint64":
+      case "fixed64":
+      case "sfixed64":
+        exampleValue =
+          optionalBehavior === "default-optional" && isOptional ? `0n` : `123n`; // BigInt for 64-bit integers
+        break;
+      case "bool":
+        exampleValue =
+          optionalBehavior === "default-optional" && isOptional
+            ? `false`
+            : `true`;
+        break;
+      case "bytes":
+        exampleValue =
+          optionalBehavior === "default-optional" && isOptional
+            ? `Buffer.from([])`
+            : `Buffer.from([1, 2, 3])`;
+        break;
+      default:
+        const resolvedType = field.resolvedType;
+        if (resolvedType && resolvedType instanceof proto.Type) {
+          if (optionalBehavior === "default-optional" && isOptional) {
+            exampleValue = "";
+          } else {
+            exampleValue = createTestInstance(resolvedType, optionalBehavior);
+          }
+        } else if (
+          field.resolvedType &&
+          field.resolvedType instanceof proto.Enum
+        ) {
+          const enumValues = Object.keys(field.resolvedType.values);
+          const middleValue = enumValues[Math.floor(enumValues.length / 2)];
+          exampleValue = `"${middleValue}"`;
+        } else {
+          logError(
+            `Unsupported field type "${fieldType}" for field "${fieldName}". Using "UNKNOWN" as placeholder.`,
+          );
+          exampleValue = "UNKNOWN";
+        }
+    }
+  }
+
+  if (!exampleValue) return null;
+
+  return omitFieldName
+    ? `${exampleValue}`
+    : `      ${fieldName}: ${exampleValue},`;
+}
+
+export { generateNamespaceTests };

package/src/generators/traits.ts

@@ -0,0 +1,141 @@
+import proto from "protobufjs";
+import {
+  lowercaseFirstLetter,
+  removeRequestSuffix,
+} from "../utils/string-manipulation.js";
+import {
+  getDeserializerFunctionName,
+  getSerializerFunctionName,
+} from "./serialization.js";
+import { getMessages } from "../utils/protobuf.js";
+import { getMessageId } from "../utils/associations.js";
+import { logError } from "../utils/logger.js";
+
+/**
+ * Generates wrapper functions for all messages and enums in a protobuf namespace, including nested namespaces, and returns the content of the wrapper file as a string.
+ * @param namespace - The protobuf namespace to create wrapper functions for
+ * @param associations - An array of tuples representing request-response message associations, where each tuple contains a request message type and its corresponding response message type. These associations are used to generate additional traits for request-response pairs.
+ * @returns A string containing the content of the wrapper file with all the generated wrapper functions for the protobuf namespace
+ */
+function createNamespaceTraits(
+  namespace: proto.Namespace,
+  associations: [proto.Type, proto.Type][],
+): string {
+  let traitsContent = "";
+  const messageTraits: string[] = [];
+  const allImports: string[] = [];
+  const messages = getMessages(namespace);
+  for (const message of messages) {
+    const result = createMessageTraits(message);
+    if (!result) {
+      continue;
+    }
+    const { definition, name, imports } = result;
+    traitsContent += definition;
+    messageTraits.push(name);
+    allImports.push(...imports);
+  }
+  const { baseName, version } = parseNamespace(namespace.name);
+  messageTraits.push("API_NAME", "API_VERSION");
+
+  let associationTraits = "";
+  for (const [request, response] of associations) {
+    const pairName = removeRequestSuffix(request.name);
+    const pairTraitsName = getReqResTraitName(pairName);
+    const requestTraitName = getTraitName(request.name);
+    const responseTraitName = getTraitName(response.name);
+    associationTraits += `const ${pairTraitsName} = {
+  name: "${pairName}",
+  request: ${requestTraitName},
+  response: ${responseTraitName},
+};\n`;
+    if (!messageTraits.includes(requestTraitName)) {
+      logError(
+        `${request.name} is missing a message ID but is detected as a request message. Please add a 'MessageId: ###' comment to it.`,
+      );
+    }
+    if (!messageTraits.includes(responseTraitName)) {
+      logError(
+        `${response.name} is missing a message ID but is detected as a response message. Please add a 'MessageId: ###' comment to it.`,
+      );
+    }
+    messageTraits.push(pairTraitsName);
+  }
+
+  return `import { ${[...new Set(allImports)].sort().join(", ")} } from "./serialization.js";
+
+const API_NAME = "${baseName}";
+const API_VERSION = ${version};
+${traitsContent}
+${associationTraits}
+export {
+  ${messageTraits.sort().join(",\n  ")}
+};
+`;
+}
+
+/**
+ * Parses a protobuf namespace name to extract the base name and version number. The expected format for the namespace name is "NamespaceV1", where "Namespace" is the base name and "1" is the version number. If the namespace name does not match this format, an error is thrown.
+ * @param namespace - The protobuf namespace name to parse
+ * @returns An object containing the base name and version number extracted from the namespace name
+ * @throws An error if the namespace name does not match the expected format
+ */
+function parseNamespace(namespace: string) {
+  const match = namespace.match(/^(.*)_?v(\d+)$/i);
+  if (!match) {
+    throw new Error(
+      `Invalid namespace format: ${namespace}. Expected format is "NamespaceV1"`,
+    );
+  }
+  return {
+    baseName: match[1]?.replace(/_?$/, "") || "", // Remove trailing underscore if present
+    version: match[2],
+  };
+}
+
+/**
+ * Creates a traits object for a protobuf message type, which includes the message ID, name, and references to the corresponding serializer and deserializer functions. If the message does not have an associated message ID, the function returns null and logs an error indicating that the message is missing a message ID.
+ * @param message - The protobuf message type to create the traits object for
+ * @returns An object containing the TypeScript definition for the traits object, the name of the traits object, and an array of imports required for the serializer and deserializer functions. If the message is missing a message ID, it returns null.
+ */
+function createMessageTraits(message: proto.Type) {
+  const id = getMessageId(message);
+  if (!id) {
+    return null;
+  }
+  const traitName = getTraitName(message.name);
+  const serialize = getSerializerFunctionName(message.name);
+  const deserialize = getDeserializerFunctionName(message.name);
+  const definition = `
+const ${traitName} = {
+  deserialize: ${deserialize},
+  id: ${id},
+  name: "${message.name}",
+  serialize: ${serialize},
+};\n`;
+  return {
+    definition,
+    name: traitName,
+    imports: [serialize, deserialize],
+  };
+}
+
+/**
+ * Generates a trait name for a protobuf message type by converting the first letter of the message name to lowercase and appending "Traits" to the end. For example, if the message name is "MyMessage", the generated trait name would be "myMessageTraits".
+ * @param messageName - The name of the protobuf message type to generate the trait name for
+ * @returns A string containing the generated trait name for the protobuf message type
+ */
+function getTraitName(messageName: string) {
+  return `${lowercaseFirstLetter(messageName)}Traits`;
+}
+
+/**
+ * Generates a trait name for a request-response pair of protobuf message types by removing the "Request" suffix from the request message name, converting the first letter to lowercase, and appending "ReqResTraits" to the end. For example, if the request message name is "GetUserRequest", the generated trait name for the request-response pair would be "getUserReqResTraits".
+ * @param pairName - The base name of the request-response pair, which is derived from the request message name by removing the "Request" suffix
+ * @returns A string containing the generated trait name for the request-response pair of protobuf message types
+ */
+function getReqResTraitName(pairName: string) {
+  return `${lowercaseFirstLetter(pairName)}ReqResTraits`;
+}
+
+export { createNamespaceTraits };