@openhps/protobuf 1.0.2 → 1.1.0

package/package.json

@@ -1,96 +1,127 @@
 {
-  "name": "@openhps/protobuf",
-  "version": "1.0.2",
-  "description": "OpenHPS Protocol Buffer Generator",
-  "main": "dist/cjs/bin/generator.js",
-  "bin": {
-    "openhps-protobuf": "./dist/cjs/bin/generator.js"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "scripts": {
-    "benchmark:1": "ts-node test/bench/serialization.bench.ts",
-    "benchmark:2": "ts-node test/bench/socket.bench.ts",
-    "benchmark:3": "ts-node test/bench/mqtt.bench.ts",
-    "start": "node dist/cjs/bin/generator.js",
-    "start:debug": "ts-node src/bin/generator.ts",
-    "test": "mocha --config test/.mocharc.json",
-    "cover": "nyc mocha --config test/.mocharc.json && nyc report --reporter=cobertura",
-    "cover:ci": "nyc mocha --config test/.mocharc.json --reporter mocha-junit-reporter && nyc report --reporter=cobertura",
-    "lint": "eslint src/**",
-    "clean": "shx rm -rf ./dist && shx rm -rf ./docs/out",
-    "build": "npm run clean && npm-run-all --parallel build:ts:* && npm run build:webpack",
-    "build:quick": "npm-run-all --parallel build:ts:* && npm run build:webpack",
-    "build:typedoc": "typedoc --options docs/typedoc.json",
-    "build:ts:cjs": "tsc --build ./tsconfig/tsconfig.bundle.cjs.json",
-    "build:ts:esm": "tsc --build ./tsconfig/tsconfig.bundle.esm.json",
-    "build:ts:esm5": "tsc --build ./tsconfig/tsconfig.bundle.esm5.json",
-    "build:ts:types": "tsc --build ./tsconfig/tsconfig.bundle.types.json",
-    "build:webpack": "npm-run-all --parallel build:webpack:*",
-    "build:webpack:prod": "webpack --env prod --",
-    "build:webpack:dev": "webpack --env dev --",
-    "publish:development": "npm run bump:beta && npm publish --tag dev",
-    "publish:beta": "npm run bump:beta && npm publish --tag beta",
-    "publish:release": "npm run bump:beta && npm publish --tag latest",
-    "bump:development": "standard-version --prerelease alpha -m 'chore(alpha): %s' --author='ci <ci@openhps.org>'",
-    "bump:beta": "standard-version --prerelease beta -m 'chore(beta): %s' --author='ci <ci@openhps.org>'",
-    "bump:release": "standard-version -m 'chore(release): %s' --author='ci <ci@openhps.org>'"
-  },
-  "files": [
-    "dist/**/*",
-    "src/**/*",
-    "LICENSE"
-  ],
-  "author": "Maxim Van de Wynckel",
-  "license": "Apache-2.0",
-  "devDependencies": {
-    "@commitlint/cli": "^19.3.0",
-    "@commitlint/config-conventional": "^19.2.2",
-    "@openhps/core": "^0.7.2",
-    "@openhps/mqtt": "^0.1.9",
-    "@openhps/rdf": "^0.4.64",
-    "@openhps/rf": "^0.1.62",
-    "@openhps/socket": "^0.1.8",
-    "@types/benchmark": "^2.1.5",
-    "@types/chai": "^4.3.16",
-    "@types/fs-extra": "^11.0.4",
-    "@types/long": "^5.0.0",
-    "@types/mocha": "^10.0.6",
-    "@types/node": "^20.14.2",
-    "@typescript-eslint/eslint-plugin": ">=7.13.0",
-    "@typescript-eslint/parser": ">=7.13.0",
-    "benchmark": "^2.1.4",
-    "buffer": "^6.0.3",
-    "eslint": "^8.56.0",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-plugin-deprecation": "^2.0.0",
-    "eslint-plugin-import": "^2.29.1",
-    "eslint-plugin-jsdoc": "^48.0.3",
-    "eslint-plugin-prettier": "^5.1.3",
-    "husky": "^9.0.11",
-    "mocha": "^10.4.0",
-    "mocha-junit-reporter": "^2.2.1",
-    "npm-run-all": "^4.1.5",
-    "nyc": "^17.0.0",
-    "prettier": "^3.3.2",
-    "reflect-metadata": ">=0.2.2",
-    "shx": "^0.3.4",
-    "standard-version": "^9.5.0",
-    "ts-node": "^10.9.2",
-    "typedoc": ">=0.25.13",
-    "typescript": "^5.4.5",
-    "webpack": "^5.92.0",
-    "webpack-cli": "^5.1.4",
-    "wkt": "^0.1.1"
-  },
-  "dependencies": {
-    "@inquirer/prompts": "^5.0.5",
-    "chai": "^4",
-    "chalk": "4.x",
-    "fs-extra": "^11.2.0",
-    "long": "^5.2.3",
-    "protobufjs": "^7.3.2",
-    "yargs": "^17.7.2"
-  }
+    "name": "@openhps/protobuf",
+    "version": "1.1.0",
+    "description": "OpenHPS Protocol Buffer Generator",
+    "author": "Maxim Van de Wynckel",
+    "license": "Apache-2.0",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/OpenHPS/openhps-protobuf.git"
+    },
+    "bugs": {
+        "url": "https://github.com/OpenHPS/openhps-protobuf/issues"
+    },
+    "homepage": "https://openhps.org",
+    "publishConfig": {
+        "access": "public"
+    },
+    "type": "commonjs",
+    "sideEffects": false,
+    "main": "./dist/cjs/index.js",
+    "types": "./dist/types/index.d.ts",
+    "module": "./dist/esm/index.js",
+    "es2015": "./dist/esm/index.js",
+    "unpkg": "./dist/web/openhps-protobuf.min.js",
+    "jsdelivr": "./dist/web/openhps-protobuf.min.js",
+    "bin": {
+        "openhps-protobuf": "./dist/cjs/bin/generator.js"
+    },
+    "exports": {
+        ".": {
+            "types": "./dist/types/index.d.ts",
+            "import": "./dist/esm/index.js",
+            "require": "./dist/cjs/index.js"
+        },
+        "./package.json": "./package.json"
+    },
+    "files": [
+        "dist/**/*",
+        "src/**/*",
+        "LICENSE"
+    ],
+    "scripts": {
+        "benchmark:1": "ts-node test/bench/serialization.bench.ts",
+        "benchmark:2": "ts-node test/bench/socket.bench.ts",
+        "benchmark:3": "ts-node test/bench/mqtt.bench.ts",
+        "start": "node dist/cjs/bin/generator.js",
+        "start:debug": "ts-node src/bin/generator.ts",
+        "test": "mocha --config test/.mocharc.json",
+        "cover": "c8 mocha --config test/.mocharc.json",
+        "cover:ci": "c8 mocha --config test/.mocharc.ci.json && c8 report --reporter=cobertura",
+        "lint": "eslint . && node scripts/check-peers.mjs",
+        "clean": "shx rm -rf ./dist && shx rm -rf ./docs/out",
+        "build": "npm run clean && npm-run-all --parallel build:ts:* && npm run build:webpack",
+        "build:quick": "npm-run-all --parallel build:ts:* && npm run build:webpack",
+        "build:typedoc": "typedoc --options docs/typedoc.json",
+        "build:ts:cjs": "tsc --build ./tsconfig/tsconfig.bundle.cjs.json",
+        "build:ts:esm": "tsc --build ./tsconfig/tsconfig.bundle.esm.json && node ./scripts/finalize-esm.mjs",
+        "build:ts:types": "tsc --build ./tsconfig/tsconfig.bundle.types.json",
+        "build:webpack": "npm-run-all --parallel build:webpack:*",
+        "build:webpack:prod": "webpack --env prod --",
+        "build:webpack:dev": "webpack --env dev --",
+        "publish:development": "npm run bump:beta && npm publish --tag dev",
+        "publish:beta": "npm run bump:beta && npm publish --tag beta",
+        "publish:release": "npm run bump:beta && npm publish --tag latest",
+        "bump:development": "commit-and-tag-version --prerelease alpha -m 'chore(alpha): %s' --skip.changelog",
+        "bump:beta": "commit-and-tag-version --prerelease beta -m 'chore(beta): %s' --skip.changelog",
+        "bump:release": "commit-and-tag-version -m 'chore(release): %s' --skip.changelog",
+        "prepare": "husky",
+        "build:golden": "shx rm -rf test/golden/protos && node -r ./test/tsconfig.js test/helpers/build-protos.ts test/golden/protos"
+    },
+    "dependencies": {
+        "@inquirer/prompts": "^5.0.5",
+        "chalk": "^4.1.2",
+        "fs-extra": "^11.4.1",
+        "long": "^5.2.3",
+        "protobufjs": "^8.8.1",
+        "tslib": "^2.9.1",
+        "yargs": "^17.7.2"
+    },
+    "devDependencies": {
+        "@commitlint/cli": "^21.2.4",
+        "@commitlint/config-conventional": "^21.2.4",
+        "@eslint/js": "^9.39.5",
+        "@openhps/core": "^1.0.16",
+        "@openhps/mqtt": "^1.0.2",
+        "@openhps/rdf": "^1.1.7",
+        "@openhps/rf": "^1.0.4",
+        "@openhps/socket": "^0.1.8",
+        "@types/benchmark": "^2.1.5",
+        "@types/chai": "^5.2.2",
+        "@types/fs-extra": "^11.0.4",
+        "@types/mocha": "^10.0.10",
+        "@types/node": "^26.6.6",
+        "benchmark": "^2.1.4",
+        "buffer": "^6.0.3",
+        "c8": "^12.0.0",
+        "chai": "^6.3.0",
+        "commit-and-tag-version": "^13.3.0",
+        "eslint": "^9.39.5",
+        "eslint-config-prettier": "^10.1.8",
+        "eslint-plugin-import": "^2.32.0",
+        "eslint-plugin-jsdoc": "^65.4.5",
+        "eslint-plugin-prettier": "^5.5.7",
+        "globals": "^17.14.0",
+        "husky": "^9.1.7",
+        "lint-staged": "^17.6.0",
+        "mocha": "^11.8.0",
+        "mocha-junit-reporter": "^2.2.1",
+        "mocha-multi-reporters": "^1.5.2",
+        "npm-run-all": "^4.1.5",
+        "prettier": "^3.10.0",
+        "reflect-metadata": ">=0.2.2",
+        "shx": "^0.4.0",
+        "terser-webpack-plugin": "^5.3.14",
+        "ts-node": "^10.9.2",
+        "typedoc": "^0.28.20",
+        "typescript": "^5.9.3",
+        "typescript-eslint": "^8.72.2",
+        "webpack": "^5.112.2",
+        "webpack-cli": "^7.3.1",
+        "wkt": "^0.1.1"
+    },
+    "engines": {
+        "node": ">=22.0.0"
+    },
+    "packageManager": "npm@10.9.2"
 }

package/src/InternalProtobufDeserializer.ts

@@ -10,18 +10,14 @@ import {
     TypedJSON,
     UUID,
 } from '@openhps/core';
-import * as protobuf from 'protobufjs';
 import { AnyT, JsonObjectMetadata } from 'typedjson';
+import type { Type } from 'protobufjs';
+import { primitiveWrapper } from './PrimitiveWrapper';
 
 export class InternalProtobufDeserializer extends Deserializer {
-    protected static primitiveWrapper: protobuf.Type;
-
     constructor() {
         super();
 
-        InternalProtobufDeserializer.primitiveWrapper = new protobuf.Type('PrimitiveWrapperMessage');
-        InternalProtobufDeserializer.primitiveWrapper.add(new protobuf.Field('value', 1, 'string'));
-
         this.setDeserializationStrategy(Number, (object: any) => {
             if (typeof object === 'number') {
                 return object;
@@ -121,7 +117,7 @@ export class InternalProtobufDeserializer extends Deserializer {
     ): IndexedObject | T | undefined {
         let expectedSelfType = typeDescriptor.ctor;
         let sourceObjectMetadata: ObjectMetadata = JsonObjectMetadata.getFromConstructor(expectedSelfType);
-        if (sourceObject.hasOwnProperty('_type') && sourceObject._type !== 0) {
+        if (Object.prototype.hasOwnProperty.call(sourceObject, '_type') && sourceObject._type !== 0) {
             const enumTypeClassname = sourceObjectMetadata.protobuf.enumMapping.get(sourceObject._type);
             if (enumTypeClassname) {
                 const enumType = knownTypes.get(enumTypeClassname);
@@ -131,18 +127,30 @@ export class InternalProtobufDeserializer extends Deserializer {
                 }
             }
         } else if (sourceObject.type_url && sourceObject.value) {
-            const MessageType = serializerOptions.types.get(sourceObject.type_url) as protobuf.Type;
-            const message = MessageType.decode(sourceObject.value);
-            const data = this.convertAsObject(
-                message,
-                new ConcreteTypeDescriptor(knownTypes.get(sourceObject.type_url)),
-                knownTypes,
-                memberName,
-                deserializer,
-                memberOptions,
-                serializerOptions,
-            );
-            return data;
+            const MessageType = serializerOptions.types.get(sourceObject.type_url) as Type;
+            if (MessageType) {
+                const message = MessageType.decode(sourceObject.value);
+                const data = this.convertAsObject(
+                    message,
+                    new ConcreteTypeDescriptor(knownTypes.get(sourceObject.type_url)),
+                    knownTypes,
+                    memberName,
+                    deserializer,
+                    memberOptions,
+                    serializerOptions,
+                );
+                return data;
+            }
+            // Unknown type: fall back to the primitive wrapper for primitive values
+            const message = primitiveWrapper.decode(sourceObject.value) as any;
+            switch (sourceObject.type_url) {
+                case 'Boolean':
+                    return (message.value === 'true') as any;
+                case 'Number':
+                    return Number(message.value) as any;
+                default:
+                    return message.value as any;
+            }
         }
 
         const sourceMetadata = sourceObjectMetadata;
@@ -162,32 +170,42 @@ export class InternalProtobufDeserializer extends Deserializer {
 
             let revivedValue;
             if (objMemberMetadata.name === 'uid') {
-                if (sourceObject.hasOwnProperty('uid_bytes') && sourceObject['uid_bytes'].byteLength > 0) {
+                if (
+                    Object.prototype.hasOwnProperty.call(sourceObject, 'uid_bytes') &&
+                    sourceObject['uid_bytes'].byteLength > 0
+                ) {
                     revivedValue = UUID.fromBuffer(sourceObject['uid_bytes']).toString();
-                } else if (sourceObject.hasOwnProperty('uid_string')) {
+                } else if (Object.prototype.hasOwnProperty.call(sourceObject, 'uid_string')) {
                     revivedValue = sourceObject['uid_string'];
                 } else {
                     return;
                 }
-            } else if (!sourceObject.hasOwnProperty(memberName) || !objMemberValue) {
+            } else if (
+                !Object.prototype.hasOwnProperty.call(sourceObject, memberName) ||
+                objMemberValue === undefined ||
+                objMemberValue === null
+            ) {
                 return;
             } else if (objMemberMetadata.type() === AnyT && objMemberValue.type_url) {
-                const MessageType = serializerOptions.types.get(sourceObject[memberName].type_url) as protobuf.Type;
+                const MessageType = serializerOptions.types.get(sourceObject[memberName].type_url) as Type;
                 if (MessageType) {
-                    const message = MessageType.decode(objMemberValue.value);
-                    revivedValue = deserializer.convertSingleValue(
-                        message,
-                        new ConcreteTypeDescriptor(knownTypes.get(objMemberValue.type_url)),
-                        knownTypes,
-                        objMemberDebugName,
-                        objMemberOptions,
-                        serializerOptions,
-                    );
+                    const messageType = knownTypes.get(objMemberValue.type_url);
+                    if (messageType !== undefined) {
+                        const message = MessageType.decode(objMemberValue.value);
+                        revivedValue = deserializer.convertSingleValue(
+                            message,
+                            new ConcreteTypeDescriptor(messageType),
+                            knownTypes,
+                            objMemberDebugName,
+                            objMemberOptions,
+                            serializerOptions,
+                        );
+                    }
                 } else if (objMemberValue.value) {
-                    const message = InternalProtobufDeserializer.primitiveWrapper.decode(objMemberValue.value) as any;
+                    const message = primitiveWrapper.decode(objMemberValue.value) as any;
                     switch (objMemberValue.type_url) {
                         case 'Boolean':
-                            revivedValue = Boolean(message.value);
+                            revivedValue = message.value === 'true';
                             break;
                         case 'Number':
                             revivedValue = Number(message.value);

package/src/InternalProtobufSerializer.ts

@@ -9,18 +9,14 @@ import {
     TypedJSON,
     UUID,
 } from '@openhps/core';
-import { Type } from 'protobufjs';
 import { AnyT, JsonObjectMetadata } from 'typedjson';
-import * as protobuf from 'protobufjs';
+import type { Type } from 'protobufjs';
+import { primitiveWrapper } from './PrimitiveWrapper';
 
 export class InternalProtobufSerializer extends Serializer {
-    protected static primitiveWrapper: Type;
-
     constructor() {
         super();
         this.setSerializationStrategy(Map, this.convertAsMap.bind(this));
-        InternalProtobufSerializer.primitiveWrapper = new protobuf.Type('PrimitiveWrapperMessage');
-        InternalProtobufSerializer.primitiveWrapper.add(new protobuf.Field('value', 1, 'string'));
     }
 
     convertSingleValue(
@@ -122,7 +118,10 @@ export class InternalProtobufSerializer extends Serializer {
                 }
             } else {
                 const MessageType = sourceTypeMetadata.protobuf.messageType;
-                const field = MessageType.get(objMemberMetadata.name);
+                // Look the field up by its wire name: members renamed through
+                // `options.protobuf.name` are emitted under that name, so the
+                // metadata name would not resolve for them.
+                const field = MessageType.get(memberName);
                 serialized = this.convertSingleValue(
                     sourceObject[objMemberMetadata.key],
                     objMemberMetadata.type(),
@@ -139,7 +138,7 @@ export class InternalProtobufSerializer extends Serializer {
                 if (objMemberMetadata.type() === AnyT) {
                     const MessageType = serializerOptions.types.get(
                         sourceObject[objMemberMetadata.key].constructor.name,
-                    ) as protobuf.Type;
+                    ) as Type;
                     if (MessageType) {
                         const message = MessageType.create(serialized);
                         serialized = {
@@ -147,12 +146,12 @@ export class InternalProtobufSerializer extends Serializer {
                             value: MessageType.encode(message).finish(),
                         };
                     } else {
-                        const message = InternalProtobufSerializer.primitiveWrapper.create({
+                        const message = primitiveWrapper.create({
                             value: String(sourceObject[objMemberMetadata.key]),
                         });
                         serialized = {
                             type_url: sourceObject[objMemberMetadata.key].constructor.name,
-                            value: InternalProtobufSerializer.primitiveWrapper.encode(message).finish(),
+                            value: primitiveWrapper.encode(message).finish(),
                         };
                     }
                 }

package/src/PrimitiveWrapper.ts

@@ -0,0 +1,9 @@
+import * as protobuf from 'protobufjs';
+
+/**
+ * Protobuf type wrapping a primitive value as a string.
+ * Shared by the serializer and the deserializer as the `google.protobuf.Any`
+ * fallback for primitive values that protobuf cannot express directly.
+ */
+export const primitiveWrapper: protobuf.Type = new protobuf.Type('PrimitiveWrapperMessage');
+primitiveWrapper.add(new protobuf.Field('value', 1, 'string'));

package/src/ProtobufSerializer.ts

@@ -8,6 +8,12 @@ import { InternalProtobufSerializer } from './InternalProtobufSerializer';
 
 export class ProtobufSerializer extends DataSerializer {
     protected static wrapperMessage: protobuf.Type;
+    /**
+     * Root holding {@link wrapperMessage}. protobufjs 8 resolves edition features by
+     * walking up to a root, and throws "Unable to find a parent for WrapperMessage" for
+     * a Type that was never added to one. Held as a field so it stays reachable.
+     */
+    protected static wrapperRoot: protobuf.Root;
     protected static options: ProtobufSerializerConfig = {
         serializer: new InternalProtobufSerializer(),
         deserializer: new InternalProtobufDeserializer(),
@@ -39,6 +45,26 @@ export class ProtobufSerializer extends DataSerializer {
     static initialize(directory?: string): Promise<void> {
         return new Promise((resolve, reject) => {
             ProtobufSerializer.root = new protobuf.Root();
+            // Reinitialisation (e.g. per test) must not accumulate stale type entries:
+            // build the new map first and only swap it in once the schemas have
+            // loaded, so a failed load keeps the previous types instead of wiping them
+            const types = new Map<string, protobuf.Type>();
+            // The generated schemas extend google.protobuf.EnumValueOptions, which is
+            // declared in descriptor.proto. protobufjs resolves imports relative to the
+            // origin file, so it looked for google/protobuf/descriptor.proto inside the
+            // generated output directory and failed with "unresolvable extensions".
+            // protobufjs ships the well-known types itself; point the resolver at them.
+            // Resolve the package root from a literal specifier: a template literal here
+            // makes webpack build a context module over the whole protobufjs package,
+            // which then tries to parse its .d.ts and tsconfig.json as bundle input.
+            const protobufRoot = path.dirname(require.resolve('protobufjs/package.json'));
+            const defaultResolve = ProtobufSerializer.root.resolvePath.bind(ProtobufSerializer.root);
+            ProtobufSerializer.root.resolvePath = (origin: string, target: string) => {
+                if (target.startsWith('google/protobuf/')) {
+                    return path.join(protobufRoot, target);
+                }
+                return defaultResolve(origin, target);
+            };
             Promise.resolve(
                 !directory ? (ProjectGenerator.buildProject(path.resolve('tmp')) as any) : Promise.resolve(),
             )
@@ -88,9 +114,10 @@ export class ProtobufSerializer extends DataSerializer {
                                             messageTypeEnum: enumNumber,
                                             enumMapping,
                                         };
-                                        this.options.types.set(className, MessageType);
+                                        types.set(className, MessageType);
                                     }
                                 });
+                                this.options.types = types;
                                 resolve();
                             })
                             .catch((error) => {
@@ -98,9 +125,11 @@ export class ProtobufSerializer extends DataSerializer {
                             });
                     });
 
+                    this.wrapperRoot = new protobuf.Root();
                     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);
+                    this.wrapperRoot.add(this.wrapperMessage);
                     return loadPromise;
                 })
                 .then(() => {
@@ -146,6 +175,9 @@ export class ProtobufSerializer extends DataSerializer {
         const decodedData: any = this.wrapperMessage.decode(serializedData);
         const typeURL = decodedData.data.type_url;
         const MessageType = this.options.types.get(typeURL) as protobuf.Type;
+        if (MessageType === undefined) {
+            throw new Error(`Unknown protobuf type '${typeURL}'`);
+        }
         const decodedMessage = MessageType.decode(decodedData.data.value);
         const finalType = dataType ?? (this.knownTypes.get(typeURL) as Constructor<T>);
         return this.options.deserializer.convertSingleValue(

package/src/bin/generator.ts

@@ -20,9 +20,9 @@ import {
     RelativeDistance,
 } from '@openhps/core';
 import { ProtobufSerializer } from '../ProtobufSerializer';
-import { expect } from 'chai';
+import assert from 'node:assert/strict';
 
-const args: [K: string] = yargs.argv as any;
+const args = yargs.argv;
 const data = {
     directory: path.normalize('tmp'),
 };
@@ -114,13 +114,13 @@ function test(): Promise<void> {
                 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;
+                assert.notStrictEqual(deserialized, undefined, 'deserialization returned 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);
+                assert.deepStrictEqual(compare1, compare2, 'round-tripped frame differs from the original');
                 console.log(chalk.green(`Basic serialization and deserialization test completed!`));
                 resolve();
             })

package/src/generator/ObjectGenerator.ts

@@ -12,20 +12,26 @@ import {
 import chalk from 'chalk';
 import { AnyT, Constructor } from 'typedjson';
 import { HEADER } from './constants';
-import { ProtobufGenerator, ProtobufMessage } from './ProtobufGenerator';
+import { ProtobufGenerator, ProtobufMessage, TypeMapping } from './ProtobufGenerator';
 import { ProjectBuildOptions } from './types';
 
+// Re-exported so the generator's public surface does not change
+export type { ProtobufPrimitive, TypeMapping } from './ProtobufGenerator';
+
 /**
  * Protobuf object generator
  */
-export class ObjectGenerator extends ProtobufGenerator<Object> { // eslint-disable-line
-    processObject(object: Constructor<Object>, metaData: ObjectMemberMetadata): Promise<void> { // eslint-disable-line
+// `Object` here is the global constructor interface used by Constructor<T>, not the wrapper type.
+/* eslint-disable @typescript-eslint/no-wrapper-object-types */
+export class ObjectGenerator extends ProtobufGenerator<Object> {
+    processObject(object: Constructor<Object>, metaData: ObjectMemberMetadata): Promise<void> {
         throw new Error('Method not implemented.');
     }
 
-    generate(object: Constructor<Object>, metaData: ObjectMemberMetadata): Promise<ProtobufMessage> { // eslint-disable-line
+    generate(object: Constructor<Object>, metaData: ObjectMemberMetadata): Promise<ProtobufMessage> {
         throw new Error('Method not implemented.');
     }
+    /* eslint-enable @typescript-eslint/no-wrapper-object-types */
 
     protected static typeMapping(
         object: ObjectMetadata,
@@ -64,6 +70,14 @@ export class ObjectGenerator extends ProtobufGenerator<Object> { // eslint-disab
                     memberOptions,
                     buildOptions,
                 );
+                // An array of a type protobuf cannot express — Set, Object, Function or
+                // a member with a custom serializer — maps to undefined, exactly as the
+                // Map case below already handles. Reading .syntax off it threw
+                // "Cannot read properties of undefined". The caller treats undefined as
+                // "omit this field".
+                if (mappings === undefined) {
+                    return undefined;
+                }
                 return {
                     syntax: `repeated ${mappings.syntax}`,
                     types: [mappings],
@@ -133,12 +147,17 @@ export class ObjectGenerator extends ProtobufGenerator<Object> { // eslint-disab
     }
 
     static processObject(object: ObjectMetadata, buildOptions: ProjectBuildOptions): void {
-        object.protobuf = object.protobuf ?? {
-            generator: {
-                subModules: new Set(),
-                subTypes: [],
-                allowOverride: true,
-            },
+        // object.protobuf is a slot shared with the runtime serializer, which fills it in
+        // as {messageType, messageTypeEnum, enumMapping} with no `generator` key. Guarding
+        // the whole object with `??` kept that value and then dereferenced a `generator`
+        // that was not there, so ProtobufSerializer.initialize() threw if anything had
+        // already initialised the serializer in the same process. Guard the two levels
+        // separately.
+        object.protobuf = object.protobuf ?? ({} as any);
+        object.protobuf.generator = object.protobuf.generator ?? {
+            subModules: new Set(),
+            subTypes: [],
+            allowOverride: true,
         };
 
         const dataMembers = object.dataMembers;
@@ -190,7 +209,8 @@ export class ObjectGenerator extends ProtobufGenerator<Object> { // eslint-disab
                 object.protobuf.generator.type = object.protobuf.generator.type ?? object.classType;
                 subTypes.forEach((type) => {
                     const subTypeMeta = DataSerializerUtils.getOwnMetadata(type);
-                    subTypeMeta.protobuf = subTypeMeta.protobuf ?? { generator: {} };
+                    subTypeMeta.protobuf = subTypeMeta.protobuf ?? ({} as any);
+                    subTypeMeta.protobuf.generator = subTypeMeta.protobuf.generator ?? {};
                     subTypeMeta.protobuf.generator.type = object.classType;
                 });
             }
@@ -250,7 +270,7 @@ export class ObjectGenerator extends ProtobufGenerator<Object> { // eslint-disab
             .map((member) => {
                 const options: any =
                     member.options && (member.options as any).protobuf ? (member.options as any).protobuf : {};
-                let type: TypeMapping = undefined;
+                let type: TypeMapping;
                 const memberName = options.name ?? member.name;
 
                 if (memberName === 'uid') {
@@ -368,11 +388,3 @@ export class ObjectGenerator extends ProtobufGenerator<Object> { // eslint-disab
         ];
     }
 }
-
-export type ProtobufPrimitive = 'string' | 'int32' | 'bool' | 'bytes';
-export interface TypeMapping {
-    syntax: ProtobufPrimitive | string;
-    types?: TypeMapping[];
-    package?: string;
-    name?: string;
-}