@alepha/protobuf 0.5.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Feunard
+
+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 @@
+# @alepha/protobuf

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@alepha/protobuf",
+  "version": "0.5.0",
+  "type": "module",
+  "license": "MIT",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.cts",
+  "dependencies": {
+    "@alepha/core": "0.5.0",
+    "protobufjs": "^7.4.0"
+  },
+  "devDependencies": {
+    "pkgroll": "^2.12.1",
+    "vitest": "^3.1.1"
+  },
+  "scripts": {
+    "build": "pkgroll --clean-dist"
+  },
+  "exports": {
+    "require": {
+      "types": "./dist/index.d.cts",
+      "default": "./dist/index.cjs"
+    },
+    "import": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from "./providers/ProtobufProvider";

package/src/providers/ProtobufProvider.ts

@@ -0,0 +1,150 @@
+import type { Static, TObject, TSchema } from "@alepha/core";
+import { $inject, Alepha, TypeGuard } from "@alepha/core";
+import type { Type } from "protobufjs";
+import protobufjs from "protobufjs";
+
+export class ProtobufProvider {
+	protected readonly alepha = $inject(Alepha);
+	protected readonly schemas = new Map<TObject | string, Type>();
+	protected readonly protobuf = protobufjs;
+
+	/**
+	 * Encode an object to a Uint8Array.
+	 *
+	 * @param schema - TypeBox schema used to generate the Protobuf schema.
+	 * @param data - Object to encode. Can be any object or string.
+	 */
+	public encode(schema: TObject, data: any): Uint8Array {
+		return this.parse(schema).encode(this.alepha.parse(schema, data)).finish();
+	}
+
+	/**
+	 * Decode a Uint8Array to an object.
+	 *
+	 * @param schema
+	 * @param data
+	 */
+	public decode<T extends TObject>(schema: T, data: Uint8Array): Static<T> {
+		return this.alepha.parse(schema, this.parse(schema).decode(data));
+	}
+
+	/**
+	 * Parse a TypeBox schema to a Protobuf Type schema ready for encoding/decoding.
+	 *
+	 * @param schema
+	 * @param typeName
+	 */
+	public parse(
+		schema: ProtobufSchema | TObject,
+		typeName = "root.Target",
+	): Type {
+		const exists = this.schemas.get(schema);
+		if (exists) return exists;
+
+		const pbSchema =
+			typeof schema === "string" ? schema : this.createProtobufSchema(schema);
+		const result = this.protobuf.parse(pbSchema);
+		const type = result.root.lookupType(typeName);
+		this.schemas.set(schema, type);
+		return type;
+	}
+
+	/**
+	 * Convert a TypeBox schema to a Protobuf schema as a string.
+	 *
+	 * @param schema
+	 * @param options
+	 */
+	public createProtobufSchema(
+		schema: TSchema,
+		options: CreateProtobufSchemaOptions = {},
+	): string {
+		const { rootName = "root", mainMessageName = "Target" } = options;
+		const context = {
+			proto: `package ${rootName};\nsyntax = "proto3";\n\n`,
+			fieldIndex: 1,
+		};
+
+		if (TypeGuard.IsObject(schema)) {
+			const proto = this.parseObject(schema, mainMessageName, context);
+			context.proto += proto;
+		}
+
+		return context.proto;
+	}
+
+	/**
+	 * Parse an object schema to a Protobuf message.
+	 *
+	 * @param obj
+	 * @param parentName
+	 * @param context
+	 * @protected
+	 */
+	protected parseObject(
+		obj: TSchema,
+		parentName: string,
+		context: { proto: string; fieldIndex: number },
+	): string {
+		if (!TypeGuard.IsObject(obj)) {
+			return "";
+		}
+
+		const fields: string[] = [];
+
+		for (const [key, value] of Object.entries(obj.properties)) {
+			if (TypeGuard.IsArray(value)) {
+				if (TypeGuard.IsObject(value.items)) {
+					const subMessageName = value.items.title ?? `${parentName}_${key}`;
+					context.proto += this.parseObject(value.items, subMessageName, {
+						...context,
+						fieldIndex: 1,
+					});
+					fields.push(
+						`  repeated ${subMessageName} ${key} = ${context.fieldIndex++};`,
+					);
+					continue;
+				}
+
+				const itemType = this.convertType(value.items);
+				fields.push(`  repeated ${itemType} ${key} = ${context.fieldIndex++};`);
+				continue;
+			}
+
+			if (TypeGuard.IsObject(value)) {
+				const subMessageName = `${parentName}_${key}`;
+				context.proto += this.parseObject(value, subMessageName, context);
+				fields.push(`  ${subMessageName} ${key} = ${context.fieldIndex++};`);
+				continue;
+			}
+
+			fields.push(
+				`  ${this.convertType(value)} ${key} = ${context.fieldIndex++};`,
+			);
+		}
+
+		return `message ${parentName} {\n${fields.join("\n")}\n}\n`;
+	}
+
+	/**
+	 * Convert a primitive TypeBox schema type to a Protobuf spec type.
+	 *
+	 * @param schema
+	 * @protected
+	 */
+	protected convertType(schema: TSchema): string {
+		if (TypeGuard.IsInteger(schema)) return "int32";
+		if (TypeGuard.IsNumber(schema)) return "double";
+		if (TypeGuard.IsString(schema)) return "string";
+		if (TypeGuard.IsBoolean(schema)) return "bool";
+
+		throw new Error(`Unsupported type: ${JSON.stringify(schema)}`);
+	}
+}
+
+export type ProtobufSchema = string;
+
+export interface CreateProtobufSchemaOptions {
+	rootName?: string;
+	mainMessageName?: string;
+}

package/test/ProtobufProvider.spec.ts

@@ -0,0 +1,41 @@
+import { Alepha, t } from "@alepha/core";
+import { test } from "vitest";
+import { ProtobufProvider } from "../src";
+
+const protobuf = Alepha.create().get(ProtobufProvider);
+const userSchema = t.object({
+	username: t.string(),
+	createdAt: t.datetime(),
+	age: t.int(),
+	isActive: t.boolean(),
+});
+
+test("ProtobufProvider#typeboxToProtobuf", async ({ expect }) => {
+	const schema = protobuf.createProtobufSchema(userSchema);
+	expect(schema).toBe(
+		`package root;
+syntax = "proto3";
+
+message Target {
+  string username = 1;
+  string createdAt = 2;
+  int32 age = 3;
+  bool isActive = 4;
+}
+`,
+	);
+});
+
+test("ProtobufProvider#encode", async ({ expect }) => {
+	const data = {
+		username: "John Doe",
+		createdAt: new Date().toISOString(),
+		age: 30,
+		isActive: true,
+	};
+	const buf = protobuf.encode(userSchema, data);
+	expect(buf).toBeInstanceOf(Uint8Array);
+
+	const user = protobuf.decode(userSchema, buf);
+	expect(user).toEqual(data);
+});

package/tsconfig.json

@@ -0,0 +1,6 @@
+{
+	"extends": "../../../tsconfig.json",
+	"compilerOptions": {
+		"outDir": "lib"
+	}
+}