Support strict:true (#154), AsObject type, add clear_ methods, fix map default values

src/field.ts

@@ -14,6 +14,18 @@ export function wrapRepeatedType(type: any, fieldDescriptor: descriptor.FieldDes
   return type;
 }
 
+/**
+ * Given the type T constructs T | undefined.
+ * Null is not added, cos Message.setWrapperField is not accepting null.
+ * @param type
+ */
+export function wrapNullableType(type: ts.TypeNode) {
+  return ts.factory.createUnionTypeNode([
+    type,
+    ts.factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword),
+  ]);
+}
+
 /**
  * @param {descriptor.FileDescriptorProto} rootDescriptor
  * @param {descriptor.FieldDescriptorProto} fieldDescriptor
@@ -31,11 +43,15 @@ export function getMapType(rootDescriptor: descriptor.FileDescriptorProto, field
 /**
  * @param {descriptor.FieldDescriptorProto} fieldDescriptor
  * @param {descriptor.FileDescriptorProto} rootDescriptor
+ * @param asObject to return message AsObject type reference
+ * @param asObjectPartial to return AsObjectPartial type referenct
  * @returns {ts.TypeReferenceNode | ts.Identifier | ts.PropertyAccessExpression}
  */
 export function getType(
   fieldDescriptor: descriptor.FieldDescriptorProto,
   rootDescriptor: descriptor.FileDescriptorProto,
+  asObject = false,
+  asObjectPartial = false,
 ): ts.TypeReferenceNode {
   if (isMap(fieldDescriptor)) {
     return getMapType(rootDescriptor, fieldDescriptor);
@@ -64,8 +80,14 @@ export function getType(
     case descriptor.FieldDescriptorProto.Type.TYPE_BYTES:
       return ts.factory.createTypeReferenceNode("Uint8Array");
     case descriptor.FieldDescriptorProto.Type.TYPE_MESSAGE:
+      return type.getTypeReference(
+        rootDescriptor,
+        fieldDescriptor.type_name,
+        asObject,
+        asObjectPartial,
+      );
     case descriptor.FieldDescriptorProto.Type.TYPE_ENUM:
-      return type.getTypeReference(rootDescriptor, fieldDescriptor.type_name)
+      return type.getTypeReference(rootDescriptor, fieldDescriptor.type_name);
     default:
       throw new Error("Unhandled type " + fieldDescriptor.type);
   }
@@ -182,7 +204,7 @@ export function isOptional(
   if (rootDescriptor.syntax == "proto3") {
     return (
       fieldDescriptor.label !=
-        descriptor.FieldDescriptorProto.Label.LABEL_REQUIRED ||
+      descriptor.FieldDescriptorProto.Label.LABEL_REQUIRED ||
       fieldDescriptor.proto3_optional
     );
   }
@@ -191,6 +213,69 @@ export function isOptional(
     descriptor.FieldDescriptorProto.Label.LABEL_OPTIONAL
   );
 }
+
+/**
+ * Function is used to determine, whether the field
+ * must always be provided when passed to a constructor or fromObject method.
+ * @param {descriptor.FileDescriptorProto} rootDescriptor
+ * @param {descriptor.FieldDescriptorProto} fieldDescriptor
+ */
+export function canBeCreatedWithoutValue(
+  rootDescriptor: descriptor.FileDescriptorProto,
+  fieldDescriptor: descriptor.FieldDescriptorProto,
+) {
+  return (
+    isOptional(rootDescriptor, fieldDescriptor) ||
+    // Both proto2 and proto3 don't track presence for maps and repeated fields.
+    // https://github.com/protocolbuffers/protobuf/blob/main/docs/field_presence.md#presence-in-proto2-apis
+    isMap(fieldDescriptor) ||
+    isRepeated(fieldDescriptor)
+  );
+}
+
+/**
+ * Function is used to determine, whether the field must be nullable
+ * in the toObject() method return type.
+ * Getters always
+ * Need to be in sync with getters.
+ * @param {descriptor.FileDescriptorProto} rootDescriptor
+ * @param {descriptor.FieldDescriptorProto} fieldDescriptor
+ */
+export function canHaveNullValue(
+  rootDescriptor: descriptor.FileDescriptorProto,
+  fieldDescriptor: descriptor.FieldDescriptorProto,
+): boolean {
+  return (
+    isOptional(rootDescriptor, fieldDescriptor) &&
+    !(
+      isNumber(fieldDescriptor) ||
+      isEnum(fieldDescriptor) ||
+      isRepeated(fieldDescriptor) ||
+      isBytes(fieldDescriptor) ||
+      isString(fieldDescriptor) ||
+      isBoolean(fieldDescriptor) ||
+      isMap(fieldDescriptor)
+    )
+    // isRequiredWithoutExplicitDefault is needed, cos
+    // protoc-gen-ts does not throw an exception when deserializing a message
+    // that does not have some required fields
+    // (neither does Google's javascript implementation).
+    // Thanks to @tomasz-szypenbejl-td for reference.
+  ) || isRequiredWithoutExplicitDefault(rootDescriptor, fieldDescriptor);
+  // Fields that are not optional and have explicit default return that default.
+  // Fields that are optional and are not messages, i.e.:
+  // (
+  //   isNumber(fieldDescriptor) ||
+  //   isEnum(fieldDescriptor) ||
+  //   isRepeated(fieldDescriptor) ||
+  //   isBytes(fieldDescriptor) ||
+  //   isString(fieldDescriptor) ||
+  //   isBoolean(fieldDescriptor) ||
+  //   isMap(fieldDescriptor)
+  // ) === true
+  // return their default value (zero, [], new Unit8Array(), '', false, new Map())
+}
+
 /**
  * @param {descriptor.FileDescriptorProto} rootDescriptor
  * @param {descriptor.FieldDescriptorProto} fieldDescriptor
@@ -218,7 +303,7 @@ export function isString(fieldDescriptor: descriptor.FieldDescriptorProto) {
 /**
  * @param {descriptor.FieldDescriptorProto} fieldDescriptor
  */
- export function isBytes(fieldDescriptor: descriptor.FieldDescriptorProto) {
+export function isBytes(fieldDescriptor: descriptor.FieldDescriptorProto) {
   return (
     fieldDescriptor.type == descriptor.FieldDescriptorProto.Type.TYPE_BYTES
   );
@@ -273,7 +358,7 @@ export function isPacked(
  * @param {descriptor.FileDescriptorProto} rootDescriptor
  * @param {descriptor.FieldDescriptorProto} fieldDescriptor
  */
- export function hasPresenceGetter(
+export function hasPresenceGetter(
   rootDescriptor: descriptor.FileDescriptorProto,
   fieldDescriptor: descriptor.FieldDescriptorProto,
 ) {

src/rpc.ts

@@ -308,9 +308,11 @@ function createUnaryRpcPromiseMethod(
   //   }
   // }
   const promiseBody = ts.factory.createCallExpression(
-    ts.factory.createPropertyAccessExpression(
-      ts.factory.createSuper(),
-      methodDescriptor.name,
+    ts.factory.createNonNullExpression(
+      ts.factory.createElementAccessExpression(
+        ts.factory.createSuper(),
+        ts.factory.createStringLiteral(methodDescriptor.name),
+      )
     ),
     undefined,
     [
@@ -794,9 +796,11 @@ function createUnaryRpcMethod(
           [
             ts.factory.createReturnStatement(
               ts.factory.createCallExpression(
-                ts.factory.createPropertyAccessExpression(
-                  ts.factory.createSuper(),
-                  methodDescriptor.name,
+                ts.factory.createNonNullExpression(
+                  ts.factory.createElementAccessExpression(
+                    ts.factory.createSuper(),
+                    ts.factory.createStringLiteral(methodDescriptor.name),
+                  )
                 ),
                 undefined,
                 [
@@ -895,9 +899,11 @@ function createClientStreamingRpcMethod(
           [
             ts.factory.createReturnStatement(
               ts.factory.createCallExpression(
-                ts.factory.createPropertyAccessExpression(
-                  ts.factory.createSuper(),
-                  methodDescriptor.name,
+                ts.factory.createNonNullExpression(
+                  ts.factory.createElementAccessExpression(
+                    ts.factory.createSuper(),
+                    ts.factory.createStringLiteral(methodDescriptor.name),
+                  )
                 ),
                 undefined,
                 [
@@ -976,9 +982,11 @@ function createServerStreamingRpcMethod(
           [
             ts.factory.createReturnStatement(
               ts.factory.createCallExpression(
-                ts.factory.createPropertyAccessExpression(
-                  ts.factory.createSuper(),
-                  methodDescriptor.name,
+                ts.factory.createNonNullExpression(
+                  ts.factory.createElementAccessExpression(
+                    ts.factory.createSuper(),
+                    ts.factory.createStringLiteral(methodDescriptor.name),
+                  )
                 ),
                 undefined,
                 [
@@ -1057,9 +1065,11 @@ function createBidiStreamingRpcMethod(
           [
             ts.factory.createReturnStatement(
               ts.factory.createCallExpression(
-                ts.factory.createPropertyAccessExpression(
-                  ts.factory.createSuper(),
-                  methodDescriptor.name,
+                ts.factory.createNonNullExpression(
+                  ts.factory.createElementAccessExpression(
+                    ts.factory.createSuper(),
+                    ts.factory.createStringLiteral(methodDescriptor.name),
+                  )
                 ),
                 undefined,
                 [

src/type.ts

@@ -68,27 +68,41 @@ export function getTypeReferenceExpr(
 export function getTypeReference(
   rootDescriptor: descriptor.FileDescriptorProto,
   typeName: string,
+  asObject = false, // add 'AsObject' to the end of the type reference
+  asObjectPartial = false, // add 'Partial', used with AsObject
 ): ts.TypeReferenceNode {
   const path = symbolMap.get(typeName);
 
   if (!path || !dependencyMap.has(path)) {
     if (config.no_namespace) {
       return ts.factory.createTypeReferenceNode(
-        removeRootParentName(typeName, rootDescriptor.package).replace(/\./g, ''),
+        addAsObject(
+          removeRootParentName(typeName, rootDescriptor.package).replace(/\./g, ""),
+          asObject,
+          asObjectPartial
+        ),
       );
     }
     return ts.factory.createTypeReferenceNode(
-      removeRootParentName(typeName, rootDescriptor.package),
+      addAsObject(
+        removeRootParentName(typeName, rootDescriptor.package),
+        asObject,
+        asObjectPartial
+      ),
     );
   }
 
-  const name = removeNamespace(removeLeadingDot(typeName));
+  const name = addAsObject(
+    removeNamespace(removeLeadingDot(typeName)),
+    asObject,
+    asObjectPartial
+  );
 
   return ts.factory.createTypeReferenceNode(
     ts.factory.createQualifiedName(
-        dependencyMap.get(path)!,
-        name,
-    )
+      dependencyMap.get(path)!,
+      name,
+    ),
   );
 }
 
@@ -106,6 +120,13 @@ function removeRootParentName(name: string, parentName: string): string {
   );
 }
 
+export function addAsObject(name: string, asObject: boolean, partial = false) {
+  if (asObject) {
+    return name + (config.no_namespace ? "" : ".") + "AsObject" + (partial ? "Partial" : "");
+  }
+  return name;
+}
+
 function removeNamespace(name: string): string {
   if(config.no_namespace)
   {

test/BUILD.bazel

@@ -13,17 +13,20 @@ diff_and_update(
     checked = PROT_SOURCES,
 )
 
+# Allow any subpackages to reference the config
+exports_files(
+    [
+        "tsconfig.json",
+    ],
+    visibility = [":__subpackages__"],
+)
+
 
 ts_project(
     name = "tests",
     srcs = glob(["*.ts"]),
-    tsconfig = {
-        "compilerOptions": {
-            "target": "ES2020",
-            "module": "CommonJS",
-            "noImplicitAny": True
-        },
-    },
+    tsconfig = {}, # no special options
+    extends = "//test:tsconfig.json",
     deps = [
         "@npm//@types/jasmine",
         "@npm//@types/node",

test/conformance.ts

@@ -13,12 +13,15 @@ export namespace main {
             pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls);
             if (!Array.isArray(data) && typeof data == "object") { }
         }
-        static fromObject(data: {}): Message {
+        static fromObject(data?: Message.AsObjectPartial): Message {
+            if (!data) {
+                return new Message();
+            }
             const message = new Message({});
             return message;
         }
         toObject() {
-            const data: {} = {};
+            const data: Message.AsObject = {};
             return data;
         }
         serialize(): Uint8Array;
@@ -46,19 +49,26 @@ export namespace main {
             return Message.deserialize(bytes);
         }
     }
+    export namespace Message {
+        export type AsObject = {};
+        export type AsObjectPartial = {};
+    }
     export class MessageResult extends pb_1.Message {
         #one_of_decls: number[][] = [];
         constructor(data?: any[] | {}) {
             super();
             pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], this.#one_of_decls);
             if (!Array.isArray(data) && typeof data == "object") { }
         }
-        static fromObject(data: {}): MessageResult {
+        static fromObject(data?: MessageResult.AsObjectPartial): MessageResult {
+            if (!data) {
+                return new MessageResult();
+            }
             const message = new MessageResult({});
             return message;
         }
         toObject() {
-            const data: {} = {};
+            const data: MessageResult.AsObject = {};
             return data;
         }
         serialize(): Uint8Array;
@@ -86,6 +96,10 @@ export namespace main {
             return MessageResult.deserialize(bytes);
         }
     }
+    export namespace MessageResult {
+        export type AsObject = {};
+        export type AsObjectPartial = {};
+    }
     interface GrpcUnaryServiceInterface<P, R> {
         (message: P, metadata: grpc_1.Metadata, options: grpc_1.CallOptions, callback: grpc_1.requestCallback<R>): grpc_1.ClientUnaryCall;
         (message: P, metadata: grpc_1.Metadata, callback: grpc_1.requestCallback<R>): grpc_1.ClientUnaryCall;
@@ -130,7 +144,7 @@ export namespace main {
             super(address, credentials, options);
         }
         Method: GrpcUnaryServiceInterface<Message, MessageResult> = (message: Message, metadata: grpc_1.Metadata | grpc_1.CallOptions | grpc_1.requestCallback<MessageResult>, options?: grpc_1.CallOptions | grpc_1.requestCallback<MessageResult>, callback?: grpc_1.requestCallback<MessageResult>): grpc_1.ClientUnaryCall => {
-            return super.Method(message, metadata, options, callback);
+            return super["Method"]!(message, metadata, options, callback);
         };
     }
 }

test/conformance/map/BUILD.bazel

@@ -27,13 +27,8 @@ diff_and_update(
 ts_project(
     name = "test_lib",
     srcs = glob(["**/*.ts"]),
-    tsconfig = {
-        "compilerOptions": {
-            "target": "ES2020",
-            "module": "CommonJS",
-            "noImplicitAny": True
-        },
-    },
+    tsconfig = {}, # no special options
+    extends = "//test:tsconfig.json",
     deps = [
         "@npm//@types/jasmine",
         "@npm//@types/node",