@dxos/codec-protobuf 2.33.9-dev.7d11f506 → 2.33.9-dev.8e92e630

package/src/encoding.ts

@@ -0,0 +1,9 @@
+//
+// Copyright 2021 DXOS.org
+//
+
+import * as protobuf from 'protobufjs';
+
+export const encodeProtobuf = (root: protobuf.Root): string => JSON.stringify(root.toJSON());
+
+export const decodeProtobuf = (json: string): protobuf.Root => protobuf.Root.fromJSON(JSON.parse(json));

package/src/index.ts

@@ -5,7 +5,9 @@
 export * from './buffer-patch';
 export * from './codec';
 export * from './common';
+export * from './encoding';
 export * from './interface';
+export * from './mapping';
 export * from './sanitizer';
 export * from './schema';
 export * from './service';

package/src/mapping.ts

@@ -2,6 +2,9 @@
 // Copyright 2020 DXOS.org
 //
 
+import assert from 'node:assert';
+import protobufjs from 'protobufjs';
+
 import { Substitutions } from './common';
 
 export type MapingDescriptors = Partial<Record<string, (value: any, ...extraArgs: any) => any>>
@@ -23,3 +26,60 @@ export const createMappingDescriptors = (substitutions: Substitutions): Bidirect
     decode
   };
 };
+
+export type FieldMapper = (value: any, typeName: string) => Promise<any>;
+
+export const mapMessage = async (type: protobufjs.Type, mapper: FieldMapper, obj: any) => {
+  const res: any = {};
+  for (const field of type.fieldsArray) {
+    if (!(field.name in obj)) {
+      continue;
+    }
+    res[field.name] = await mapField(field, mapper, obj[field.name]);
+  }
+
+  return res;
+};
+
+const mapField = async (field: protobufjs.Field, mapper: FieldMapper, value: any) => {
+  if (!field.required && (value === null || value === undefined)) {
+    return value;
+  } else if (field.repeated) {
+    return await Promise.all(value.map((value: any) => mapScalarField(field, mapper, value)));
+  } else if (field.map) {
+    assert(field instanceof protobufjs.MapField);
+    return await asyncObjectMap((value) => mapScalarField(field, mapper, value), value);
+  } else {
+    return mapScalarField(field, mapper, value);
+  }
+};
+
+const mapScalarField = async (field: protobufjs.Field, mapper: FieldMapper, value: any) => {
+  if (!field.resolved) {
+    field.resolve();
+  }
+
+  const typeName = field.resolvedType?.fullName.slice(1); // Name of the protobuf message type if the field type is not primitive.
+  if (typeName) {
+    return await mapper(value, typeName);
+  }
+
+  if (field.resolvedType && field.resolvedType instanceof protobufjs.Type) {
+    return await mapMessage(field.resolvedType, mapper, value);
+  }
+
+  return value;
+};
+
+const asyncObjectMap = async <K extends keyof any, T, U>(
+  map: (value: T, key: K) => Promise<U>,
+  record: Record<K, T>
+): Promise<Record<K, U>> => {
+  const res: Record<K, U> = {} as any;
+
+  await Promise.all(Object.entries(record).map(async ([key, value]) => {
+    res[key as keyof typeof res] = await map(value as T, key as K);
+  }));
+
+  return res;
+};

package/src/precompiled-mapping/create-message-mapper.ts

@@ -2,7 +2,7 @@
 // Copyright 2022 DXOS.org
 //
 
-import assert from 'assert';
+import assert from 'node:assert';
 import * as pb from 'protobufjs';
 
 import { MapingDescriptors } from '../mapping';
@@ -33,7 +33,6 @@ const createMessageMapperCached = (type: pb.Type, substitutions: MapingDescripto
             }
           };
 
-          // TODO(dmaretskyi): Support maps.
           if (field.repeated) {
             c`res.${field.name} = obj.${field.name}.map(item => `;
             genMapScalar('item');
@@ -52,6 +51,11 @@ const createMessageMapperCached = (type: pb.Type, substitutions: MapingDescripto
             c`;`;
           }
         } c`}`;
+        if (!field.getOption('proto3_optional') && !field.repeated && !field.map && !field.partOf) {
+          c`else {`; {
+            c`${ref(throwMissingFieldError)}('${field.name}', '${field.parent!.fullName.slice(1)}')`;
+          } c`}`;
+        }
       }
       c`return res;`;
     });
@@ -59,3 +63,7 @@ const createMessageMapperCached = (type: pb.Type, substitutions: MapingDescripto
 
   return cache[type.fullName];
 };
+
+const throwMissingFieldError = (fieldName: string, typeName: string) => {
+  throw new Error(`Missing field: ${fieldName} on ${typeName}`);
+};

package/src/service.ts

@@ -2,15 +2,15 @@
 // Copyright 2021 DXOS.org
 //
 
-import assert from 'assert';
+import assert from 'node:assert';
 import pb from 'protobufjs';
 
 import type { Schema } from './schema';
 import { Stream } from './stream';
 
 export interface Any {
-  'type_url'?: string;
-  value?: Uint8Array;
+  'type_url': string;
+  value: Uint8Array;
 }
 
 export interface ServiceBackend {

package/src/stream.ts

@@ -2,8 +2,8 @@
 // Copyright 2021 DXOS.org
 //
 
-import assert from 'assert';
 import debug from 'debug';
+import assert from 'node:assert';
 
 const log = debug('dxos:codec-protobuf:stream');