Symbol missing from generated types

Codegen will create typescript definitions that do not include the MESSAGE_TYPE symbol, even though it will be present in all response messages.

Following the example in the manual for this definition:

message Person {
    string name = 1;
    uint64 id = 2;
    int32 years = 3 [json_name = "baz"];
    optional bytes data = 5;
}

I would expect that the typescript interface is something like:

import { MessageType, MESSAGE_TYPE } from '@protobuf-ts/runtime';

export interface Person {
    /**
     * @generated from protobuf field: string name = 1;
     */
    name: string;
    /**
     * @generated from protobuf field: uint64 id = 2;
     */
    id: bigint;
    /**
     * @generated from protobuf field: int32 years = 3 [json_name = "baz"];
     */
    years: number;
    /**
     * maybe a jpeg?
     *
     * @generated from protobuf field: optional bytes data = 5;
     */
    data?: Uint8Array;


    // This what's missing
    [MESSAGE_TYPE]: MessageType<Person>
}

[timostamm]

Ah, WeakMap is definitely a nice idea. I’ve been using it back in the days in ActionScript and didn’t realize JavaScript implementations finally caught up 😃

Can’t think of any drawbacks. We export both symbols, so it is a breaking change, but it seems worth it for a new major.

[jcready]

@timostamm I wonder if we could avoid the whole mess of extra properties on the objects by using a WeakMap to store the message type (and possibly the unknown fields). Something to consider for v3.

// runtime/src/message-type-contract.ts
const MessageTypeMap = new WeakMap<object, IMessageType<any>>();
export const getMessageType = <T extends object>(ref: T): IMessageType<T> | undefined => MessageTypeMap.get(ref);

// runtime/src/binary-format-contract.ts
const UnknownFieldMap = new WeakMap<object, UnknownField[]>();
export const getUnknownFields = (ref: object): UnknownField[] | undefined => UnknownFieldMap.get(ref);

// Usage
import { getMessageType, getUnknownFields, IMessageType, UnknownField } from '@protobuf-ts/runtime';

const MessageType: IMessageType<typeof someReference> | undefined = getMessageType(someReference);
if (MessageType) {
    console.log(MessageType.toJson(someReference));
}

const UnknownFields: UnknownField[] | undefined = getUnknownFields(someReference);
if (UnknownFields) {
    console.log(UnknownFields.map((uf) => uf.no));
}