Provide a way to wrap create message

[wenerme]

Due to limitations in the current implementation, as discussed in the following issues:

• Support google.type.(date|datetime|timeofday) #227
• Support google.type.Money #226
• Support for google.protobuf.Timestamp as string #1015

I had to override the entire create function to support custom types (e.g., Date initialization for google.protobuf.Timestamp), resulting in the following custom implementation:

export function createMessage<Desc extends DescMessage>(
  schema: Desc,
  init?: MessageInitShape<Desc>,
): MessageShape<Desc> {
  if (isMessage(init, schema)) {
    return init;
  }
  // Support for Date type
  if (init instanceof Date) {
    if (schema.typeName === 'google.protobuf.Timestamp') {
      return timestampFromDate(init) as any;
    }
  }
  const message = createZeroMessage(schema) as MessageShape<Desc>;
  if (init !== undefined) {
    initMessage(schema, message, init);
  }
  return message;
}

While this works, it requires duplicating and modifying the original create function, which is neither clean nor maintainable.

Proposed Solution

I propose extending the create function to accept an additional option for custom creation logic. This would allow users to define their custom type conversions without overriding the entire function.

Here’s an example implementation of the proposed solution:

export function createMessage2<Desc extends DescMessage>(
  schema: Desc,
  init?: MessageInitShape<Desc>,
): MessageShape<Desc> {
  return create(schema, init, {
    // provide a custom create function
    create: (schema, init) => {
      if (init instanceof Date) {
        if (schema.typeName === 'google.protobuf.Timestamp') {
          return timestampFromDate(init) as any;
        }
      }
      return create(schema, init);
    },
  });
}

This change would allow create to pass the custom logic to the internal toMessage function. While it may not resolve type-checking errors for MessageInit entirely, it would provide a flexible workaround for custom type conversions with minimal effort.

Benefits

• Reduces the need for duplicating the create function.
• Provides a cleaner and more maintainable solution for handling custom type conversions.
• Maintains backward compatibility by introducing an optional parameter.

Would it be possible to consider implementing this enhancement? It would greatly improve the extensibility and usability of the create function.

---

Disclaimer: I am a non-native English speaker, and this issue description has been improved with the assistance of AI. Please let me know if anything needs further clarification.