protobufjs load .proto and encode messages: working versions (tested 2026-10-15)

{
  "name": "protobufjs-proto-encode",
  "private": true,
  "type": "module",
  "scripts": {
    "test": "node --import tsx --test test/*.test.ts"
  },
  "dependencies": {
    "protobufjs": "8.8.1"
  },
  "devDependencies": {
    "@types/node": "26.6.5",
    "tsx": "4.23.15"
  }
}

syntax = "proto3";
package demo;

message Person {
  string name = 1;
  int32 id = 2;
  string email = 3;
}

import protobuf from "protobufjs";
import { fileURLToPath } from "node:url";
import { dirname, join } from "node:path";

const here = dirname(fileURLToPath(import.meta.url));

export type Person = { name: string; id: number; email: string };

export async function loadPersonType() {
  const root = await protobuf.load(join(here, "person.proto"));
  return root.lookupType("demo.Person");
}

export function encodePerson(Type: protobuf.Type, person: Person) {
  const err = Type.verify(person);
  if (err) throw new Error(err);
  const message = Type.create(person);
  return Type.encode(message).finish();
}

export function decodePerson(Type: protobuf.Type, buf: Uint8Array): Person {
  return Type.toObject(Type.decode(buf), { defaults: true }) as Person;
}

import { test } from "node:test";
import assert from "node:assert/strict";
import { decodePerson, encodePerson, loadPersonType } from "../src/codec.ts";

test("encodes and decodes a Person", async () => {
  const Type = await loadPersonType();
  const person = { name: "Ada", id: 7, email: "[email protected]" };
  const buf = encodePerson(Type, person);
  assert.ok(buf.byteLength > 0);
  assert.deepEqual(decodePerson(Type, buf), person);
});

test("verify rejects missing required shape via bad types", async () => {
  const Type = await loadPersonType();
  // proto3 has no required fields; verify still accepts strings/ints
  const buf = encodePerson(Type, { name: "", id: 0, email: "" });
  assert.deepEqual(decodePerson(Type, buf), { name: "", id: 0, email: "" });
});