@aptre/protobuf-es-lite 0.3.1 → 0.4.1

package/dist/message.d.ts

@@ -38,10 +38,14 @@ export interface MessageType<T extends Message<T> = AnyMessage> {
      * When used as a field, unwrap this message to a simple value.
      */
     readonly fieldWrapper?: FieldWrapper<T>;
+    /**
+     * Create a new empty instance of this message applying the partial message.
+     */
+    create(partial?: Message<T>): Message<T>;
     /**
      * Create a new instance of this message with zero values for fields.
      */
-    create(partial?: Message<T>): CompleteMessage<T>;
+    createComplete(partial?: Message<T>): CompleteMessage<T>;
     /**
      * Create a deep copy.
      */
@@ -107,8 +111,8 @@ export type MessageTypeParams<T extends Message<T>> = Pick<MessageType<T>, "fiel
  */
 export declare function createMessageType<T extends Message<T>, E extends Record<string, Function> = {}>(params: MessageTypeParams<T>, exts?: E): MessageType<T> & E;
 export declare function compareMessages<T extends Message<T>>(fields: FieldList, a: T | undefined | null, b: T | undefined | null): boolean;
-export declare function cloneMessage<T extends Message<T>>(message: T, fields: FieldList): T;
+export declare function cloneMessage<T extends Message<T>>(message: T | null | undefined, fields: FieldList): T | null;
 /**
- * createMessage recursively builds a message filled with zero values based on the given FieldList.
+ * createCompleteMessage recursively builds a message filled with zero values based on the given FieldList.
  */
-export declare function createMessage<T extends Message<T>>(fields: FieldList): CompleteMessage<T>;
+export declare function createCompleteMessage<T extends Message<T>>(fields: FieldList): CompleteMessage<T>;

package/dist/message.js

@@ -13,9 +13,11 @@
 // limitations under the License.
 import { newFieldList, resolveMessageType, } from "./field.js";
 import { applyPartialMessage } from "./partial.js";
-import { ScalarType, scalarEquals } from "./scalar.js";
+import { LongType, ScalarType, scalarEquals, scalarZeroValue, } from "./scalar.js";
 import { binaryReadMessage, binaryWriteMessage, binaryMakeReadOptions, binaryMakeWriteOptions, } from "./binary.js";
 import { jsonReadMessage, jsonWriteMessage, jsonMakeReadOptions, jsonMakeWriteOptions, } from "./json.js";
+import { throwSanitizeKey } from "./names.js";
+import { enumZeroValue } from "./enum.js";
 /**
  * createMessageType creates a new message type.
  *
@@ -30,7 +32,12 @@ export function createMessageType(params, exts) {
         fields,
         fieldWrapper,
         create(partial) {
-            const message = createMessage(fields);
+            const message = Object.create(null);
+            applyPartialMessage(partial, message, fields);
+            return message;
+        },
+        createComplete(partial) {
+            const message = createCompleteMessage(fields);
             applyPartialMessage(partial, message, fields);
             return message;
         },
@@ -47,7 +54,7 @@ export function createMessageType(params, exts) {
             const message = {};
             if (bytes && bytes.length) {
                 const opt = binaryMakeReadOptions(options);
-                binaryReadMessage(message, fields, opt.readerFactory(bytes), bytes.byteLength, opt, delimitedMessageEncoding);
+                binaryReadMessage(message, fields, opt.readerFactory(bytes), bytes.byteLength, opt, delimitedMessageEncoding ?? false);
             }
             return message;
         },
@@ -104,9 +111,12 @@ export function compareMessages(fields, a, b) {
         const va = a[m.localName];
         const vb = b[m.localName];
         if (m.repeated) {
-            if (va.length !== vb.length) {
+            if ((va?.length ?? 0) !== (vb?.length ?? 0)) {
                 return false;
             }
+            if (!va?.length) {
+                return true;
+            }
             // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- repeated fields are never "map"
             switch (m.kind) {
                 case "message":
@@ -127,9 +137,12 @@ export function compareMessages(fields, a, b) {
             case "scalar":
                 return scalarEquals(m.T, va, vb);
             case "oneof":
-                if (va.case !== vb.case) {
+                if (va?.case !== vb?.case) {
                     return false;
                 }
+                if (va == null) {
+                    return true;
+                }
                 const s = m.findField(va.case);
                 if (s === undefined) {
                     return true;
@@ -160,129 +173,55 @@ export function compareMessages(fields, a, b) {
         }
     });
 }
-// clone a single field value - i.e. the element type of repeated fields, the value type of maps
-function cloneSingularField(value, fieldInfo) {
-    if (value === undefined) {
-        return value;
-    }
-    if (fieldInfo.kind === "message") {
-        return cloneMessage(value, resolveMessageType(fieldInfo.T).fields);
-    }
-    if (fieldInfo.kind === "oneof") {
-        if (value.case === undefined) {
-            return undefined;
-        }
-        const selectedField = fieldInfo.findField(value.case);
-        if (!selectedField) {
-            throw new Error(`Invalid oneof case "${value.case}" for ${fieldInfo.name}`);
-        }
-        return {
-            case: value.case,
-            value: cloneSingularField(value.value, selectedField),
-        };
-    }
-    if (value instanceof Uint8Array) {
-        const c = new Uint8Array(value.byteLength);
-        c.set(value);
-        return c;
-    }
-    return value;
-}
-// TODO use isFieldSet() here to support future field presence
 export function cloneMessage(message, fields) {
-    const clone = {};
-    for (const member of fields.byMember()) {
-        const source = message[member.localName];
-        let copy;
-        if (member.repeated) {
-            copy = source.map((v) => cloneSingularField(v, member));
-        }
-        else if (member.kind == "map") {
-            copy = {};
-            for (const [key, v] of Object.entries(source)) {
-                copy[key] = cloneSingularField(v, member);
-            }
-        }
-        else if (member.kind == "oneof") {
-            const f = member.findField(source.case);
-            copy =
-                f ?
-                    { case: source.case, value: cloneSingularField(source.value, member) }
-                    : { case: undefined };
-        }
-        else {
-            copy = cloneSingularField(source, member);
-        }
-        clone[member.localName] = copy;
+    if (message == null) {
+        return null;
     }
+    const clone = Object.create(null);
+    applyPartialMessage(message, clone, fields, true);
     return clone;
 }
 /**
- * createMessage recursively builds a message filled with zero values based on the given FieldList.
+ * createCompleteMessage recursively builds a message filled with zero values based on the given FieldList.
  */
-export function createMessage(fields) {
+export function createCompleteMessage(fields) {
     const message = {};
-    for (const field of fields.list()) {
-        const fieldKind = field.kind;
+    for (const field of fields.byMember()) {
+        const { localName, kind: fieldKind } = field;
+        throwSanitizeKey(localName);
         switch (fieldKind) {
+            case "oneof":
+                message[localName] = Object.create(null);
+                message[localName].case = undefined;
+                break;
             case "scalar":
                 if (field.repeated) {
-                    message[field.localName] = [];
+                    message[localName] = [];
                 }
                 else {
-                    switch (field.T) {
-                        case ScalarType.DOUBLE:
-                        case ScalarType.FLOAT:
-                            message[field.localName] = 0;
-                            break;
-                        case ScalarType.INT64:
-                        case ScalarType.UINT64:
-                        case ScalarType.INT32:
-                        case ScalarType.FIXED64:
-                        case ScalarType.FIXED32:
-                        case ScalarType.UINT32:
-                        case ScalarType.SFIXED32:
-                        case ScalarType.SFIXED64:
-                        case ScalarType.SINT32:
-                        case ScalarType.SINT64:
-                            message[field.localName] = 0;
-                            break;
-                        case ScalarType.BOOL:
-                            message[field.localName] = false;
-                            break;
-                        case ScalarType.STRING:
-                            message[field.localName] = "";
-                            break;
-                        case ScalarType.BYTES:
-                            message[field.localName] =
-                                new Uint8Array();
-                            break;
-                    }
+                    message[localName] = scalarZeroValue(field.T, LongType.BIGINT);
                 }
                 break;
             case "enum":
-                if (field.repeated) {
-                    message[field.localName] = [];
-                }
-                else {
-                    message[field.localName] = 0;
-                }
+                message[localName] = field.repeated ? [] : enumZeroValue(field.T);
                 break;
             case "message":
+                // oneofs are handled above
                 if (field.oneof) {
-                    message[field.localName] = undefined;
-                    continue;
+                    break;
                 }
-                const messageType = resolveMessageType(field.T);
                 if (field.repeated) {
-                    message[field.localName] = [];
-                }
-                else {
-                    message[field.localName] = createMessage(messageType.fields);
+                    message[localName] = [];
+                    break;
                 }
+                const messageType = resolveMessageType(field.T);
+                message[localName] =
+                    !!messageType.fieldWrapper ?
+                        messageType.fieldWrapper.unwrapField(null)
+                        : createCompleteMessage(messageType.fields);
                 break;
             case "map":
-                message[field.localName] = {};
+                message[localName] = Object.create(null);
                 break;
             default:
                 field;

package/dist/names.d.ts

@@ -41,3 +41,5 @@ export declare const safeObjectProperty: (name: string) => string;
  * Names that can be used for identifiers or class properties
  */
 export declare const safeIdentifier: (name: string) => string;
+export declare function checkSanitizeKey(key: string): boolean;
+export declare function throwSanitizeKey(key: string): void;

package/dist/names.js

@@ -32,12 +32,7 @@ export function localName(desc) {
             const pkg = desc.file.proto.package;
             const offset = pkg === undefined ? 0 : pkg.length + 1;
             const name = desc.typeName.substring(offset).replace(/\./g, "_");
-            // For services, we only care about safe identifiers, not safe object properties,
-            // but we have shipped v1 with a bug that respected object properties, and we
-            // do not want to introduce a breaking change, so we continue to escape for
-            // safe object properties.
-            // See https://github.com/bufbuild/protobuf-es/pull/391
-            return safeObjectProperty(safeIdentifier(name));
+            return safeIdentifier(name);
         }
         case "enum_value": {
             let name = desc.name;
@@ -219,20 +214,7 @@ const reservedObjectProperties = new Set([
  * Names that cannot be used for object properties because they are reserved
  * by the runtime.
  */
-const reservedMessageProperties = new Set([
-    // names reserved by the runtime
-    "getType",
-    "clone",
-    "equals",
-    "fromBinary",
-    "fromJson",
-    "fromJsonString",
-    "toBinary",
-    "toJson",
-    "toJsonString",
-    // names reserved by the runtime for the future
-    "toObject",
-]);
+const reservedMessageProperties = new Set(["__proto__"]);
 const fallback = (name) => `${name}$`;
 /**
  * Will wrap names that are Object prototype properties or names reserved
@@ -263,3 +245,14 @@ export const safeIdentifier = (name) => {
     }
     return name;
 };
+export function checkSanitizeKey(key) {
+    return typeof key === "string" && key !== "__proto__";
+}
+export function throwSanitizeKey(key) {
+    if (typeof key !== "string") {
+        throw new Error("illegal non-string object key: " + typeof key);
+    }
+    if (!checkSanitizeKey(key)) {
+        throw new Error("illegal object key: " + key);
+    }
+}

package/dist/partial.d.ts

@@ -1,3 +1,4 @@
-import { FieldList } from "./field.js";
+import { FieldList, MapValueInfo } from "./field.js";
 import { Message } from "./message.js";
-export declare function applyPartialMessage<T extends Message<T>>(source: Message<T> | undefined, target: Message<T>, fields: FieldList): void;
+export declare function applyPartialMessage<T extends Message<T>>(source: Message<T> | undefined, target: Message<T>, fields: FieldList, clone?: boolean): void;
+export declare function applyPartialMap(sourceMap: Record<string, any> | undefined, targetMap: Record<string, any>, value: MapValueInfo, clone: boolean): void;

package/dist/partial.js

@@ -1,99 +1,196 @@
+import { normalizeEnumValue } from "./enum.js";
 import { resolveMessageType } from "./field.js";
-import { ScalarType } from "./scalar.js";
-// applyPartialMessage applies a partial message to a message.
-export function applyPartialMessage(source, target, fields) {
-    if (source === undefined) {
+import { createCompleteMessage } from "./message.js";
+import { throwSanitizeKey } from "./names.js";
+import { normalizeScalarValue } from "./scalar.js";
+// applyPartialMessage applies a partial source message to a target message.
+//
+// if clone is set: values are deep-copied including Uint8Arrays.
+export function applyPartialMessage(source, target, fields, clone = false) {
+    if (source == null || target == null) {
         return;
     }
+    const t = target, s = source;
     for (const member of fields.byMember()) {
-        const localName = member.localName, t = target, s = source;
-        if (s[localName] === undefined) {
+        const localName = member.localName;
+        throwSanitizeKey(localName);
+        if (!(localName in s) || s[localName] === undefined) {
+            continue;
+        }
+        const sourceValue = s[localName];
+        if (sourceValue === null) {
+            delete t[localName];
             continue;
         }
         switch (member.kind) {
             case "oneof":
-                const sk = s[localName].case;
-                if (sk === undefined) {
-                    continue;
+                if (typeof sourceValue !== "object") {
+                    throw new Error(`field ${localName}: invalid oneof: must be an object with case and value`);
+                }
+                // sk, sk are the source case and value
+                const { case: sk, value: sv } = sourceValue;
+                // sourceField is the field set by the source case, if any.
+                const sourceField = sk != null ? member.findField(sk) : null;
+                // dv is the destination oneof object
+                let dv = localName in t ? t[localName] : undefined;
+                if (typeof dv !== "object") {
+                    dv = Object.create(null);
+                }
+                // check the case is valid and throw if not
+                if (sk != null && sourceField == null) {
+                    throw new Error(`field ${localName}: invalid oneof case: ${sk}`);
+                }
+                // update the case
+                dv.case = sk;
+                // if the case was different or null, clear the value.
+                if (dv.case !== sk || sk == null) {
+                    delete dv.value;
                 }
-                const sourceField = member.findField(sk);
-                let val = s[localName].value;
-                if (sourceField?.kind == "message") {
-                    if (val === undefined) {
-                        val = {};
+                t[localName] = dv;
+                // stop here if there was no valid case selected
+                if (!sourceField) {
+                    break;
+                }
+                if (sourceField.kind === "message") {
+                    // apply the partial to the value
+                    let dest = dv.value;
+                    if (typeof dest !== "object") {
+                        dest = dv.value = Object.create(null);
+                    }
+                    // skip zero or null value
+                    if (sv != null) {
+                        const sourceFieldMt = resolveMessageType(sourceField.T);
+                        applyPartialMessage(sv, dest, sourceFieldMt.fields);
                     }
                 }
-                else if (sourceField &&
-                    sourceField.kind === "scalar" &&
-                    sourceField.T === ScalarType.BYTES) {
-                    val = toU8Arr(val);
+                else if (sourceField.kind === "scalar") {
+                    dv.value = normalizeScalarValue(sourceField.T, sv, clone);
+                }
+                else {
+                    dv.value = sv;
                 }
-                t[localName] = { case: sk, value: val };
                 break;
             case "scalar":
+                if (member.repeated) {
+                    if (!Array.isArray(sourceValue)) {
+                        throw new Error(`field ${localName}: invalid value: must be array`);
+                    }
+                    let dst = localName in t ? t[localName] : null;
+                    if (dst == null || !Array.isArray(dst)) {
+                        dst = t[localName] = [];
+                    }
+                    dst.push(...sourceValue.map((v) => normalizeScalarValue(member.T, v, clone)));
+                    break;
+                }
+                t[localName] = normalizeScalarValue(member.T, sourceValue, clone);
+                break;
             case "enum":
-                let copy = s[localName];
-                if (member.T === ScalarType.BYTES) {
-                    copy =
-                        member.repeated ?
-                            copy.map(toU8Arr)
-                            : toU8Arr(copy);
-                }
-                t[localName] = copy;
+                t[localName] = normalizeEnumValue(member.T, sourceValue);
                 break;
             case "map":
-                switch (member.V.kind) {
-                    case "scalar":
-                    case "enum":
-                        if (member.V.T === ScalarType.BYTES) {
-                            for (const [k, v] of Object.entries(s[localName])) {
-                                t[localName][k] = toU8Arr(v);
-                            }
-                        }
-                        else {
-                            Object.assign(t[localName], s[localName]);
-                        }
-                        break;
-                    case "message":
-                        const messageType = resolveMessageType(member.V.T);
-                        for (const k of Object.keys(s[localName])) {
-                            let val = s[localName][k];
-                            if (!messageType.fieldWrapper) {
-                                if (val === undefined) {
-                                    val = {};
-                                }
-                            }
-                            t[localName][k] = val;
-                        }
-                        break;
+                if (typeof sourceValue !== "object") {
+                    throw new Error(`field ${member.localName}: invalid value: must be object`);
+                }
+                let tMap = t[localName];
+                if (typeof tMap !== "object") {
+                    tMap = t[localName] = Object.create(null);
                 }
+                applyPartialMap(sourceValue, tMap, member.V, clone);
                 break;
             case "message":
                 const mt = resolveMessageType(member.T);
                 if (member.repeated) {
-                    t[localName] = s[localName].map((val) => val ?? {});
+                    // skip null or undefined values
+                    if (!Array.isArray(sourceValue)) {
+                        throw new Error(`field ${localName}: invalid value: must be array`);
+                    }
+                    let tArr = t[localName];
+                    if (!Array.isArray(tArr)) {
+                        tArr = t[localName] = [];
+                    }
+                    for (const v of sourceValue) {
+                        // skip null or undefined values
+                        if (v != null) {
+                            if (mt.fieldWrapper) {
+                                tArr.push(mt.fieldWrapper.unwrapField(mt.fieldWrapper.wrapField(v)));
+                            }
+                            else {
+                                tArr.push(mt.create(v));
+                            }
+                        }
+                    }
+                    break;
+                }
+                if (mt.fieldWrapper) {
+                    t[localName] = mt.fieldWrapper.unwrapField(mt.fieldWrapper.wrapField(sourceValue));
                 }
                 else {
-                    const val = s[localName];
-                    if (mt.fieldWrapper) {
-                        if (
-                        // We can't use BytesValue.typeName as that will create a circular import
-                        mt.typeName === "google.protobuf.BytesValue") {
-                            t[localName] = toU8Arr(val);
-                        }
-                        else {
-                            t[localName] = val;
-                        }
+                    if (typeof sourceValue !== "object") {
+                        throw new Error(`field ${member.localName}: invalid value: must be object`);
                     }
-                    else {
-                        t[localName] = val ?? {};
+                    let destMsg = t[localName];
+                    if (typeof destMsg !== "object") {
+                        destMsg = t[localName] = Object.create(null);
                     }
+                    applyPartialMessage(sourceValue, destMsg, mt.fields);
                 }
                 break;
         }
     }
 }
-// converts any ArrayLike<number> to Uint8Array if necessary.
-function toU8Arr(input) {
-    return input instanceof Uint8Array ? input : new Uint8Array(input);
+// applyPartialMap applies a partial source map to a target map.
+export function applyPartialMap(sourceMap, targetMap, value, clone) {
+    if (sourceMap == null) {
+        return;
+    }
+    if (typeof sourceMap !== "object") {
+        throw new Error(`invalid map: must be object`);
+    }
+    switch (value.kind) {
+        case "scalar":
+            for (const [k, v] of Object.entries(sourceMap)) {
+                throwSanitizeKey(k);
+                if (v !== undefined) {
+                    targetMap[k] = normalizeScalarValue(value.T, v, clone);
+                }
+                else {
+                    delete targetMap[k];
+                }
+            }
+            break;
+        case "enum":
+            for (const [k, v] of Object.entries(sourceMap)) {
+                throwSanitizeKey(k);
+                if (v !== undefined) {
+                    targetMap[k] = normalizeEnumValue(value.T, v);
+                }
+                else {
+                    delete targetMap[k];
+                }
+            }
+            break;
+        case "message":
+            const messageType = resolveMessageType(value.T);
+            for (const [k, v] of Object.entries(sourceMap)) {
+                throwSanitizeKey(k);
+                if (v === undefined) {
+                    delete targetMap[k];
+                    continue;
+                }
+                if (typeof v !== "object") {
+                    throw new Error(`invalid value: must be object`);
+                }
+                let val = targetMap[k];
+                if (!!messageType.fieldWrapper) {
+                    // For wrapper type messages, call createCompleteMessage.
+                    val = targetMap[k] = createCompleteMessage(messageType.fields);
+                }
+                else if (typeof val !== "object") {
+                    // Otherwise apply the partial to the existing value, if any.
+                    val = targetMap[k] = Object.create(null);
+                }
+                applyPartialMessage(v, val, messageType.fields);
+            }
+            break;
+    }
 }

package/dist/protoc-gen-es-lite/typescript.js

@@ -384,9 +384,17 @@ function generateWktMethods(schema, f, message, ref) {
             f.print("    }");
             f.print(`    return new Date(ms).toISOString().replace(".000Z", z);`);
             f.print("  },");
-            f.print("  toDate(msg: ", message, "): Date {");
+            f.print("  toDate(msg: ", message, " | null | undefined): Date | null {");
+            f.print("    if (!msg?.", localName(ref.seconds), " && !msg?.", localName(ref.nanos), ") { return null; }");
             f.print("    return new Date(Number(msg.", localName(ref.seconds), " ?? 0) * 1000 + Math.ceil((msg.", localName(ref.nanos), " ?? 0) / 1000000));");
             f.print("  },");
+            f.print("  fromDate(value: Date | null | undefined): ", message, " {");
+            f.print("    if (value == null) { return {}; }");
+            f.print("    const ms = value.getTime();");
+            f.print("    const seconds = Math.floor(ms / 1000);");
+            f.print("    const nanos = (ms % 1000) * 1000000;");
+            f.print("    return { ", localName(ref.seconds), ": ", protoInt64, ".parse(seconds), ", localName(ref.nanos), ": nanos };");
+            f.print("  },");
             break;
         case "google.protobuf.Duration":
             f.print("  fromJson(json: ", JsonValue, " | null | undefined, _options?: Partial<", JsonReadOptions, ">): ", message, " {");
@@ -552,6 +560,30 @@ function generateWktMethods(schema, f, message, ref) {
 }
 function generateWktFieldWrapper(f, message, ref) {
     switch (ref?.typeName) {
+        /* TODO Wrap Timestamp => Date
+        case "google.protobuf.Timestamp": {
+          f.print("  fieldWrapper: {");
+          f.print(
+            "    wrapField(value: ",
+            message,
+            " | Date | null | undefined): ",
+            message,
+            " {",
+          );
+          f.print(
+            "      if (value == null || value instanceof Date) { return ",
+            message,
+            "_Wkt.fromDate(value); }",
+          );
+          f.print("      return ", message, ".createComplete(value);");
+          f.print("    },");
+          f.print("    unwrapField(msg: ", message, "): Date | null {");
+          f.print("      return ", message, "_Wkt.toDate(msg);");
+          f.print("    }");
+          f.print("  } as const,");
+          break;
+        }
+        */
         case "google.protobuf.DoubleValue":
         case "google.protobuf.FloatValue":
         case "google.protobuf.Int64Value":
@@ -564,7 +596,7 @@ function generateWktFieldWrapper(f, message, ref) {
             const { typing } = getFieldTypeInfo(ref.value);
             f.print("  fieldWrapper: {");
             f.print("    wrapField(value: ", typing, " | null | undefined): ", message, " {");
-            f.print("      return ", message, ".create({ value: value ?? undefined });");
+            f.print("      return ", message, ".createComplete({ value: value ?? undefined });");
             f.print("    },");
             f.print("    unwrapField(msg: ", message, "): ", typing, " | null | undefined {");
             f.print("      return msg.", localName(ref.value), ";");

package/dist/scalar.d.ts

@@ -67,3 +67,12 @@ export declare function scalarZeroValue<T extends ScalarType, L extends LongType
  * optional or repeated.
  */
 export declare function isScalarZeroValue(type: ScalarType, value: unknown): boolean;
+/**
+ * Returns the normalized version of the scalar value.
+ * Zero or null is cast to the zero value.
+ * Bytes is cast to a Uint8Array.
+ * The BigInt long type is used.
+ * If clone is set, Uint8Array will always be copied to a new value.
+ */
+export declare function normalizeScalarValue<T>(type: ScalarType, value: T | null | undefined, clone: boolean, longType?: LongType): T;
+export declare function toU8Arr(input: ArrayLike<number>, clone: boolean): Uint8Array;