@openhps/protobuf 1.0.0

package/src/ProtobufSerializer.ts

@@ -0,0 +1,168 @@
+import { Constructor, DataSerializer, DataSerializerConfig, DataSerializerUtils } from '@openhps/core';
+import * as path from 'path';
+import * as protobuf from 'protobufjs';
+import * as fs from 'fs';
+import { ProjectGenerator } from './generator';
+import { InternalProtobufDeserializer } from './InternalProtobufDeserializer';
+import { InternalProtobufSerializer } from './InternalProtobufSerializer';
+
+export class ProtobufSerializer extends DataSerializer {
+    protected static wrapperMessage: protobuf.Type;
+    protected static options: ProtobufSerializerConfig = {
+        serializer: new InternalProtobufSerializer(),
+        deserializer: new InternalProtobufDeserializer(),
+        types: new Map(),
+    };
+    protected static root: protobuf.Root;
+
+    private static getFiles(directory: string, files: string[] = []): string[] {
+        if (!fs.statSync(directory).isDirectory()) {
+            return [];
+        }
+        const fileList = fs.readdirSync(path.normalize(directory));
+        for (const file of fileList) {
+            const name = `${directory}/${file}`;
+            if (fs.statSync(name).isDirectory()) {
+                this.getFiles(name, files);
+            } else if (name.endsWith('.proto')) {
+                files.push(path.normalize(name));
+            }
+        }
+        return files;
+    }
+
+    /**
+     * Initialize the protocol buffer serializer
+     * @param {string} [directory] Directory of generated protocol messages. Default will generate on the fly
+     * @returns {Promise<void>} Promise once initialized
+     */
+    static initialize(directory?: string): Promise<void> {
+        return new Promise((resolve, reject) => {
+            ProtobufSerializer.root = new protobuf.Root();
+            Promise.resolve(
+                !directory ? (ProjectGenerator.buildProject(path.resolve('tmp')) as any) : Promise.resolve(),
+            )
+                .then(() => {
+                    const files = this.getFiles(path.resolve(directory ?? 'tmp'));
+                    const loadPromise: Promise<void> = new Promise((resolve) => {
+                        ProtobufSerializer.root
+                            .load(files, {
+                                keepCase: true,
+                            })
+                            .then(() => {
+                                files.forEach((file) => {
+                                    const className = path.parse(file).name;
+                                    const knownType = this.knownTypes.get(className);
+                                    if (knownType) {
+                                        const objectMeta = DataSerializerUtils.getOwnMetadata(
+                                            this.knownTypes.get(className),
+                                        );
+                                        const rootMeta = DataSerializerUtils.getRootMetadata(
+                                            this.knownTypes.get(className),
+                                        );
+                                        const MessageType = ProtobufSerializer.root.lookupType(className);
+                                        let enumNumber = undefined;
+                                        const enumMapping: Map<number, string> = new Map();
+                                        try {
+                                            const typeEnum = ProtobufSerializer.root.lookupEnum(
+                                                `${rootMeta.classType.name}Type`,
+                                            );
+                                            Object.keys(typeEnum.values).forEach((key, id) => {
+                                                if (id === 0) {
+                                                    return; // Unspecified
+                                                }
+                                                const otherClassName = typeEnum.valuesOptions[key]['(className)'];
+                                                if (otherClassName === className) {
+                                                    enumNumber = typeEnum.values[key];
+                                                }
+                                                enumMapping.set(
+                                                    typeEnum.values[key],
+                                                    typeEnum.valuesOptions[key]['(className)'],
+                                                );
+                                            });
+                                        } catch (ex) {
+                                            // Ignore :')
+                                        }
+                                        objectMeta.protobuf = {
+                                            messageType: MessageType,
+                                            messageTypeEnum: enumNumber,
+                                            enumMapping,
+                                        };
+                                        this.options.types.set(className, MessageType);
+                                    }
+                                });
+                                resolve();
+                            })
+                            .catch((error) => {
+                                return reject(error);
+                            });
+                    });
+
+                    this.wrapperMessage = new protobuf.Type('WrapperMessage');
+                    this.wrapperMessage.add(new protobuf.Field('data', 1, 'google.protobuf.Any'));
+                    this.wrapperMessage.addJSON(protobuf.common['google/protobuf/any.proto'].nested);
+                    return loadPromise;
+                })
+                .then(() => {
+                    console.log(ProtobufSerializer.root.toJSON());
+                    resolve();
+                })
+                .catch(reject);
+        });
+    }
+
+    /**
+     * Serialize data
+     * @param {any} data Data to serialize
+     * @param {DataSerializerConfig} [config] Data serializer configuration
+     * @returns {Uint8Array} Serialized buffer
+     */
+    static serialize<T>(data: T, config?: DataSerializerConfig): Uint8Array {
+        const serializedData = super.serialize(data, {
+            ...this.options,
+            ...config,
+        });
+        const MessageType = this.options.types.get(data.constructor.name) as protobuf.Type;
+        const message = MessageType.fromObject(serializedData);
+        const wrapper = this.wrapperMessage.create({
+            data: {
+                type_url: data.constructor.name,
+                value: MessageType.encode(message).finish(),
+            },
+        });
+        return this.wrapperMessage.encode(wrapper).finish();
+    }
+
+    /**
+     * Deserialize data
+     * @param serializedData Data to deserialze
+     * @param dataType Optional data type to specify deserialization type
+     * @param config Data serializer configuration
+     */
+    static deserialize<T>(
+        serializedData: Uint8Array | any,
+        dataType?: Constructor<T>,
+        config?: DataSerializerConfig,
+    ): T {
+        const decodedData: any = this.wrapperMessage.decode(serializedData);
+        const typeURL = decodedData.data.type_url;
+        const MessageType = this.options.types.get(typeURL) as protobuf.Type;
+        const decodedMessage = MessageType.decode(decodedData.data.value);
+        const finalType = dataType ?? (this.knownTypes.get(typeURL) as Constructor<T>);
+        return this.options.deserializer.convertSingleValue(
+            decodedMessage,
+            DataSerializerUtils.ensureTypeDescriptor(finalType),
+            DataSerializer.knownTypes,
+            undefined,
+            undefined,
+            {
+                ...config,
+                ...this.options,
+            },
+        );
+    }
+}
+
+export interface ProtobufSerializerConfig extends DataSerializerConfig {
+    types: Map<string, protobuf.Type>;
+}

package/src/bin/generator.ts

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+
+import chalk from 'chalk';
+import { ProjectGenerator } from '../generator/';
+import '@openhps/rf';
+import * as path from 'path';
+import { input } from '@inquirer/prompts';
+import * as yargs from 'yargs';
+import {
+    Absolute3DPosition,
+    Accuracy1D,
+    AngleUnit,
+    DataFrame,
+    DataObject,
+    DataSerializer,
+    LengthUnit,
+    LinearVelocity,
+    LinearVelocityUnit,
+    Orientation,
+    RelativeDistance,
+} from '@openhps/core';
+import { ProtobufSerializer } from '../ProtobufSerializer';
+import { expect } from 'chai';
+
+const args: [K: string] = yargs.argv as any;
+const data = {
+    directory: path.normalize('tmp'),
+};
+
+/**
+ * Main CLI entry
+ */
+function main() {
+    console.log(chalk.redBright('OpenHPS Protocol Buffer Generator'));
+
+    if (args['help'] || args['?']) {
+        console.log('Command line arguments:');
+        console.log('-d <dir>\t\tSpecify the output directory to create the protocol buffer messages.');
+        console.log('-v\t\tVerbose logging.');
+        process.exit();
+    }
+
+    Promise.resolve(
+        args['d'] ??
+            input({
+                message: 'Enter the output directory',
+            }),
+    ).then((directory) => {
+        data.directory = directory;
+        prepare();
+        generate();
+    });
+}
+
+/**
+ *
+ */
+function prepare() {
+    console.log('Detected serializable packages:');
+    ProjectGenerator.getPackages().map((module) => {
+        console.log(`\t${module}`);
+    });
+}
+
+/**
+ *
+ */
+function generate() {
+    ProjectGenerator.buildProject(data.directory, {
+        logLevel: args['v'] ? 3 : 2,
+        useAnyType: args['any'] !== undefined,
+    })
+        .then((count) => {
+            console.log(chalk.green(`${count} protocol buffer messages created!`));
+            return test();
+        })
+        .then(() => {
+            process.exit();
+        })
+        .catch((ex: Error) => {
+            console.error(chalk.red(ex.stack));
+            process.exit(-1);
+        });
+}
+
+/**
+ *
+ */
+function test(): Promise<void> {
+    return new Promise((resolve, reject) => {
+        console.log(`Performing a self-test of the protocol buffer messages ...`);
+        // Load data
+        ProtobufSerializer.initialize(data.directory)
+            .then(() => {
+                // Generic example
+                const frame = new DataFrame();
+                const object = new DataObject('test', 'Test Object');
+                object.setPosition(new Absolute3DPosition(1, 2, 3, LengthUnit.METER));
+                object.position.orientation = Orientation.fromEuler({
+                    yaw: 50,
+                    roll: 10,
+                    pitch: 10,
+                    unit: AngleUnit.DEGREE,
+                });
+                object.position.velocity.linear = new LinearVelocity(
+                    1,
+                    0,
+                    0,
+                    LinearVelocityUnit.METER_PER_SECOND,
+                ).setAccuracy(new Accuracy1D(1, LinearVelocityUnit.CENTIMETER_PER_SECOND));
+                object.position.orientation.accuracy = new Accuracy1D(10, AngleUnit.DEGREE);
+                object.addRelativePosition(new RelativeDistance('test2', 10, LengthUnit.METER));
+                frame.source = object;
+                frame.addObject(new DataObject('test2', 'Test Object 2'));
+                const buffer = ProtobufSerializer.serialize(frame);
+                const deserialized: DataFrame = ProtobufSerializer.deserialize(buffer);
+                expect(deserialized).to.not.be.undefined;
+                const compare1 = JSON.stringify(DataSerializer.serialize(deserialized), null, 2);
+                const compare2 = JSON.stringify(DataSerializer.serialize(frame), null, 2);
+                // console.log(compare1);
+                // console.log('\n');
+                // console.log(compare2);
+                expect(compare1).to.eql(compare2);
+                console.log(chalk.green(`Basic serialization and deserialization test completed!`));
+                resolve();
+            })
+            .catch(reject);
+    });
+}
+
+main();

package/src/decorators/index.ts

@@ -0,0 +1 @@
+import './options';

package/src/decorators/options.ts

@@ -0,0 +1,30 @@
+import { SerializableObjectOptions, MemberOptionsBase, ObjectMetadata, Serializable } from '@openhps/core';
+import { Type } from 'protobufjs';
+
+export type { SerializableObjectOptions, MemberOptionsBase, ObjectMetadata };
+
+declare module '@openhps/core/dist/types/data/decorators/options' {
+    export interface MemberOptionsBase {
+        protobuf?: {
+            optional?: boolean;
+            name?: string;
+        };
+    }
+}
+
+declare module '@openhps/core/dist/types/data/decorators/metadata' {
+    export interface ObjectMetadata {
+        protobuf?: {
+            messageType?: Type;
+            messageTypeEnum?: number;
+            enumMapping?: Map<number, string>;
+            generator?: {
+                subTypes?: Serializable<any>[];
+                subModules?: Set<string>;
+                type?: Serializable<any>;
+                dataMembers?: Map<string, ObjectMemberMetadata & { subMembers?: Map<string, ObjectMemberMetadata> }>;
+                allowOverride?: boolean;
+            };
+        };
+    }
+}