@alepha/protobuf 0.5.0 → 0.5.1

package/dist/index.cjs

@@ -0,0 +1,124 @@
+'use strict';
+
+var core = require('@alepha/core');
+var protobufjs = require('protobufjs');
+
+class ProtobufProvider {
+  alepha = core.$inject(core.Alepha);
+  schemas = /* @__PURE__ */ new Map();
+  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.
+   */
+  encode(schema, data) {
+    return this.parse(schema).encode(this.alepha.parse(schema, data)).finish();
+  }
+  /**
+   * Decode a Uint8Array to an object.
+   *
+   * @param schema
+   * @param data
+   */
+  decode(schema, data) {
+    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
+   */
+  parse(schema, typeName = "root.Target") {
+    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
+   */
+  createProtobufSchema(schema, options = {}) {
+    const { rootName = "root", mainMessageName = "Target" } = options;
+    const context = {
+      proto: `package ${rootName};
+syntax = "proto3";
+
+`,
+      fieldIndex: 1
+    };
+    if (core.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
+   */
+  parseObject(obj, parentName, context) {
+    if (!core.TypeGuard.IsObject(obj)) {
+      return "";
+    }
+    const fields = [];
+    for (const [key, value] of Object.entries(obj.properties)) {
+      if (core.TypeGuard.IsArray(value)) {
+        if (core.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 (core.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} {
+${fields.join("\n")}
+}
+`;
+  }
+  /**
+   * Convert a primitive TypeBox schema type to a Protobuf spec type.
+   *
+   * @param schema
+   * @protected
+   */
+  convertType(schema) {
+    if (core.TypeGuard.IsInteger(schema)) return "int32";
+    if (core.TypeGuard.IsNumber(schema)) return "double";
+    if (core.TypeGuard.IsString(schema)) return "string";
+    if (core.TypeGuard.IsBoolean(schema)) return "bool";
+    throw new Error(`Unsupported type: ${JSON.stringify(schema)}`);
+  }
+}
+
+exports.ProtobufProvider = ProtobufProvider;

package/dist/index.d.cts

@@ -0,0 +1,103 @@
+import { Alepha, TObject, Static, TSchema as TSchema$1 } from '@alepha/core';
+import protobufjs, { Type } from 'protobufjs';
+
+/** Symbol key applied to readonly types */
+declare const ReadonlyKind: unique symbol;
+/** Symbol key applied to optional types */
+declare const OptionalKind: unique symbol;
+/** Symbol key applied to types */
+declare const Hint: unique symbol;
+/** Symbol key applied to types */
+declare const Kind: unique symbol;
+
+type TPropertyKey = string | number;
+type TProperties = Record<TPropertyKey, TSchema>;
+
+interface SchemaOptions {
+    $schema?: string;
+    /** Id for this schema */
+    $id?: string;
+    /** Title of this schema */
+    title?: string;
+    /** Description of this schema */
+    description?: string;
+    /** Default value for this schema */
+    default?: any;
+    /** Example values matching this schema */
+    examples?: any;
+    /** Optional annotation for readOnly */
+    readOnly?: boolean;
+    /** Optional annotation for writeOnly */
+    writeOnly?: boolean;
+    [prop: string]: any;
+}
+interface TKind {
+    [Kind]: string;
+}
+interface TSchema extends TKind, SchemaOptions {
+    [ReadonlyKind]?: string;
+    [OptionalKind]?: string;
+    [Hint]?: string;
+    params: unknown[];
+    static: unknown;
+}
+
+declare class ProtobufProvider {
+    protected readonly alepha: Alepha;
+    protected readonly schemas: Map<string | TObject<TProperties>, Type>;
+    protected readonly protobuf: typeof 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.
+     */
+    encode(schema: TObject, data: any): Uint8Array;
+    /**
+     * Decode a Uint8Array to an object.
+     *
+     * @param schema
+     * @param data
+     */
+    decode<T extends TObject>(schema: T, data: Uint8Array): Static<T>;
+    /**
+     * Parse a TypeBox schema to a Protobuf Type schema ready for encoding/decoding.
+     *
+     * @param schema
+     * @param typeName
+     */
+    parse(schema: ProtobufSchema | TObject, typeName?: string): Type;
+    /**
+     * Convert a TypeBox schema to a Protobuf schema as a string.
+     *
+     * @param schema
+     * @param options
+     */
+    createProtobufSchema(schema: TSchema$1, options?: CreateProtobufSchemaOptions): string;
+    /**
+     * Parse an object schema to a Protobuf message.
+     *
+     * @param obj
+     * @param parentName
+     * @param context
+     * @protected
+     */
+    protected parseObject(obj: TSchema$1, parentName: string, context: {
+        proto: string;
+        fieldIndex: number;
+    }): string;
+    /**
+     * Convert a primitive TypeBox schema type to a Protobuf spec type.
+     *
+     * @param schema
+     * @protected
+     */
+    protected convertType(schema: TSchema$1): string;
+}
+type ProtobufSchema = string;
+interface CreateProtobufSchemaOptions {
+    rootName?: string;
+    mainMessageName?: string;
+}
+
+export { type CreateProtobufSchemaOptions, ProtobufProvider, type ProtobufSchema };

package/dist/index.d.mts

@@ -0,0 +1,103 @@
+import { Alepha, TObject, Static, TSchema as TSchema$1 } from '@alepha/core';
+import protobufjs, { Type } from 'protobufjs';
+
+/** Symbol key applied to readonly types */
+declare const ReadonlyKind: unique symbol;
+/** Symbol key applied to optional types */
+declare const OptionalKind: unique symbol;
+/** Symbol key applied to types */
+declare const Hint: unique symbol;
+/** Symbol key applied to types */
+declare const Kind: unique symbol;
+
+type TPropertyKey = string | number;
+type TProperties = Record<TPropertyKey, TSchema>;
+
+interface SchemaOptions {
+    $schema?: string;
+    /** Id for this schema */
+    $id?: string;
+    /** Title of this schema */
+    title?: string;
+    /** Description of this schema */
+    description?: string;
+    /** Default value for this schema */
+    default?: any;
+    /** Example values matching this schema */
+    examples?: any;
+    /** Optional annotation for readOnly */
+    readOnly?: boolean;
+    /** Optional annotation for writeOnly */
+    writeOnly?: boolean;
+    [prop: string]: any;
+}
+interface TKind {
+    [Kind]: string;
+}
+interface TSchema extends TKind, SchemaOptions {
+    [ReadonlyKind]?: string;
+    [OptionalKind]?: string;
+    [Hint]?: string;
+    params: unknown[];
+    static: unknown;
+}
+
+declare class ProtobufProvider {
+    protected readonly alepha: Alepha;
+    protected readonly schemas: Map<string | TObject<TProperties>, Type>;
+    protected readonly protobuf: typeof 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.
+     */
+    encode(schema: TObject, data: any): Uint8Array;
+    /**
+     * Decode a Uint8Array to an object.
+     *
+     * @param schema
+     * @param data
+     */
+    decode<T extends TObject>(schema: T, data: Uint8Array): Static<T>;
+    /**
+     * Parse a TypeBox schema to a Protobuf Type schema ready for encoding/decoding.
+     *
+     * @param schema
+     * @param typeName
+     */
+    parse(schema: ProtobufSchema | TObject, typeName?: string): Type;
+    /**
+     * Convert a TypeBox schema to a Protobuf schema as a string.
+     *
+     * @param schema
+     * @param options
+     */
+    createProtobufSchema(schema: TSchema$1, options?: CreateProtobufSchemaOptions): string;
+    /**
+     * Parse an object schema to a Protobuf message.
+     *
+     * @param obj
+     * @param parentName
+     * @param context
+     * @protected
+     */
+    protected parseObject(obj: TSchema$1, parentName: string, context: {
+        proto: string;
+        fieldIndex: number;
+    }): string;
+    /**
+     * Convert a primitive TypeBox schema type to a Protobuf spec type.
+     *
+     * @param schema
+     * @protected
+     */
+    protected convertType(schema: TSchema$1): string;
+}
+type ProtobufSchema = string;
+interface CreateProtobufSchemaOptions {
+    rootName?: string;
+    mainMessageName?: string;
+}
+
+export { type CreateProtobufSchemaOptions, ProtobufProvider, type ProtobufSchema };

package/dist/index.mjs

@@ -0,0 +1,122 @@
+import { $inject, Alepha, TypeGuard } from '@alepha/core';
+import protobufjs from 'protobufjs';
+
+class ProtobufProvider {
+  alepha = $inject(Alepha);
+  schemas = /* @__PURE__ */ new Map();
+  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.
+   */
+  encode(schema, data) {
+    return this.parse(schema).encode(this.alepha.parse(schema, data)).finish();
+  }
+  /**
+   * Decode a Uint8Array to an object.
+   *
+   * @param schema
+   * @param data
+   */
+  decode(schema, data) {
+    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
+   */
+  parse(schema, typeName = "root.Target") {
+    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
+   */
+  createProtobufSchema(schema, options = {}) {
+    const { rootName = "root", mainMessageName = "Target" } = options;
+    const context = {
+      proto: `package ${rootName};
+syntax = "proto3";
+
+`,
+      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
+   */
+  parseObject(obj, parentName, context) {
+    if (!TypeGuard.IsObject(obj)) {
+      return "";
+    }
+    const fields = [];
+    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} {
+${fields.join("\n")}
+}
+`;
+  }
+  /**
+   * Convert a primitive TypeBox schema type to a Protobuf spec type.
+   *
+   * @param schema
+   * @protected
+   */
+  convertType(schema) {
+    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 { ProtobufProvider };

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@alepha/protobuf",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "type": "module",
   "license": "MIT",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.cts",
   "dependencies": {
-    "@alepha/core": "0.5.0",
+    "@alepha/core": "0.5.1",
     "protobufjs": "^7.4.0"
   },
   "devDependencies": {

package/test/ProtobufProvider.spec.ts

@@ -1,41 +0,0 @@
-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

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