@dxos/protobuf-compiler 2.33.5-dev.b7c9d504 → 2.33.5-dev.b9f5bea6

package/src/generator/types.ts

@@ -17,20 +17,18 @@ import { SubstitutionsMap } from '../parser';
 
 const f = ts.factory;
 
-function createSubstitutionsReference (type: string): ts.TypeNode {
-  return f.createTypeReferenceNode(
-    f.createIdentifier('ReturnType'),
-    [f.createIndexedAccessTypeNode(
-      f.createIndexedAccessTypeNode(
-        f.createTypeQueryNode(f.createIdentifier('substitutions')),
-        f.createLiteralTypeNode(f.createStringLiteral(type))
-      ),
-      f.createLiteralTypeNode(f.createStringLiteral('decode'))
-    )]
-  );
-}
+const createSubstitutionsReference = (type: string): ts.TypeNode => f.createTypeReferenceNode(
+  f.createIdentifier('ReturnType'),
+  [f.createIndexedAccessTypeNode(
+    f.createIndexedAccessTypeNode(
+      f.createTypeQueryNode(f.createIdentifier('substitutions')),
+      f.createLiteralTypeNode(f.createStringLiteral(type))
+    ),
+    f.createLiteralTypeNode(f.createStringLiteral('decode'))
+  )]
+);
 
-function getPrimitiveType (type: string): ts.TypeNode {
+const getPrimitiveType = (type: string): ts.TypeNode => {
   switch (type) {
     case 'double':
       return f.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
@@ -65,11 +63,11 @@ function getPrimitiveType (type: string): ts.TypeNode {
     default:
       return f.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);
   }
-}
+};
 
 type PbType = protobufjs.Enum | protobufjs.Type | string
 
-export function types (type: PbType, containingObject: protobufjs.ReflectionObject, subs: SubstitutionsMap) {
+export const types = (type: PbType, containingObject: protobufjs.ReflectionObject, subs: SubstitutionsMap) => {
   if (typeof type === 'string') {
     return getPrimitiveType(type);
   } else if (type.fullName === '.google.protobuf.Empty') {
@@ -79,9 +77,9 @@ export function types (type: PbType, containingObject: protobufjs.ReflectionObje
   } else {
     return getTypeReference(type, containingObject);
   }
-}
+};
 
-export function getTypeReference (to: protobufjs.ReflectionObject, from?: protobufjs.ReflectionObject) {
+export const getTypeReference = (to: protobufjs.ReflectionObject, from?: protobufjs.ReflectionObject) => {
   const toNamespace = getNamespaceName(to);
   const fromNamespace = from && getNamespaceName(from);
 
@@ -92,4 +90,4 @@ export function getTypeReference (to: protobufjs.ReflectionObject, from?: protob
     const name = [getSafeNamespaceIdentifier(toNamespace), ...getFullNestedTypeName(to)];
     return f.createTypeReferenceNode(convertNameToIdentifier(name));
   }
-}
+};

package/src/module-specifier.ts

@@ -49,18 +49,18 @@ export class ModuleSpecifier {
 
 export const CODEC_MODULE = new ModuleSpecifier('@dxos/codec-protobuf', __dirname);
 
-function normalizeRelativePath (path: string) {
+const normalizeRelativePath = (path: string) => {
   if (!path.startsWith('.')) {
     return `./${path}`;
   } else {
     return path;
   }
-}
+};
 
-function removeExtension (path: string, extension: string) {
+const removeExtension = (path: string, extension: string) => {
   if (path.endsWith(extension)) {
     return path.slice(0, -extension.length);
   } else {
     return path;
   }
-}
+};

package/src/namespaces.ts

@@ -10,19 +10,17 @@ const f = ts.factory;
 
 export type DeclarationFullName = string[];
 
-export function getFullNestedTypeName (type: pb.ReflectionObject): DeclarationFullName {
+export const getFullNestedTypeName = (type: pb.ReflectionObject): DeclarationFullName => {
   if (type.parent && type.parent instanceof pb.Type) {
     return [...getFullNestedTypeName(type.parent), type.name];
   } else {
     return [type.name];
   }
-}
+};
 
-function isType (obj: pb.ReflectionObject): obj is (pb.Type | pb.Enum | pb.Service) {
-  return obj instanceof pb.Type || obj instanceof pb.Enum || obj instanceof pb.Service;
-}
+const isType = (obj: pb.ReflectionObject): obj is (pb.Type | pb.Enum | pb.Service) => obj instanceof pb.Type || obj instanceof pb.Enum || obj instanceof pb.Service;
 
-export function getNamespaceName (type: pb.ReflectionObject): DeclarationFullName {
+export const getNamespaceName = (type: pb.ReflectionObject): DeclarationFullName => {
   if (type.parent) {
     if (!isType(type)) {
       return [...getNamespaceName(type.parent), type.name];
@@ -32,9 +30,9 @@ export function getNamespaceName (type: pb.ReflectionObject): DeclarationFullNam
   } else {
     return [];
   }
-}
+};
 
-export function getRelativeName (target: DeclarationFullName, base: DeclarationFullName): DeclarationFullName {
+export const getRelativeName = (target: DeclarationFullName, base: DeclarationFullName): DeclarationFullName => {
   // TODO(marik-d): Optimization: Remove recursion.
   if (target.length === 1 || base.length === 1) {
     return target;
@@ -43,42 +41,36 @@ export function getRelativeName (target: DeclarationFullName, base: DeclarationF
   } else {
     return target;
   }
-}
+};
 
-export function convertNameToIdentifier (name: DeclarationFullName): ts.QualifiedName | ts.Identifier {
+export const convertNameToIdentifier = (name: DeclarationFullName): ts.QualifiedName | ts.Identifier => {
   if (name.length === 1) {
     return f.createIdentifier(name[0]);
   } else {
     return f.createQualifiedName(convertNameToIdentifier(name.slice(0, -1)), name[name.length - 1]);
   }
-}
+};
 
-export function stringifyFullyQualifiedName (name: DeclarationFullName) {
-  return name.join('.');
-}
+export const stringifyFullyQualifiedName = (name: DeclarationFullName) => name.join('.');
 
-export function normalizeFullyQualifiedName (name: string) {
+export const normalizeFullyQualifiedName = (name: string) => {
   if (name.startsWith('.')) {
     return name.slice(1);
   } else {
     return name;
   }
-}
+};
 
-export function parseFullyQualifiedName (name: string): DeclarationFullName {
+export const parseFullyQualifiedName = (name: string): DeclarationFullName => {
   const norm = normalizeFullyQualifiedName(name);
   return norm.split('.');
-}
+};
 
-export function namesEqual (a: DeclarationFullName, b: DeclarationFullName) {
-  return a.length === b.length && a.every((_, i) => a[i] === b[i]);
-}
+export const namesEqual = (a: DeclarationFullName, b: DeclarationFullName) => a.length === b.length && a.every((_, i) => a[i] === b[i]);
 
-export function getSafeNamespaceIdentifier (name: DeclarationFullName) {
-  return name.join('_');
-}
+export const getSafeNamespaceIdentifier = (name: DeclarationFullName) => name.join('_');
 
-export function splitSchemaIntoNamespaces (root: pb.Namespace): Map<string, pb.ReflectionObject[]> {
+export const splitSchemaIntoNamespaces = (root: pb.Namespace): Map<string, pb.ReflectionObject[]> => {
   const res = new Map<string, pb.ReflectionObject[]>();
 
   const namespace = normalizeFullyQualifiedName(root.fullName);
@@ -101,4 +93,4 @@ export function splitSchemaIntoNamespaces (root: pb.Namespace): Map<string, pb.R
   }
 
   return res;
-}
+};

package/src/parser/resolver.ts

@@ -36,6 +36,6 @@ export function createProtoResolver (original: ProtoResolver): ProtoResolver {
 }
 
 const resovler = createProtoResolver(pb.Root.prototype.resolvePath);
-export function registerResolver () {
+export const registerResolver = () => {
   pb.Root.prototype.resolvePath = resovler;
-}
+};

package/src/parser/substitutions-parser.ts

@@ -17,19 +17,19 @@ export interface ImportDescriptor {
  */
 export type SubstitutionsMap = Partial<Record<string, string>>
 
-function getSubstitutionType (substitutionProperty: Symbol, typeChecker: TypeChecker) {
+const getSubstitutionType = (substitutionProperty: Symbol, typeChecker: TypeChecker) => {
   const substitutionType = typeChecker.getTypeOfSymbolAtLocation(substitutionProperty, substitutionProperty.getValueDeclarationOrThrow());
 
   const decode = substitutionType.getPropertyOrThrow('decode');
   const decodeType = typeChecker.getTypeOfSymbolAtLocation(decode, decode.getValueDeclarationOrThrow());
 
   return decodeType.getCallSignatures()[0].getReturnType();
-}
+};
 
 /**
  * Parse a protobuf-substitutions file and return a map of protobuf FQN => Typescript identifier.
  */
-export function parseSubstitutionsFile (fileName: string): SubstitutionsMap {
+export const parseSubstitutionsFile = (fileName: string): SubstitutionsMap => {
   const project = new Project({
     tsConfigFilePath: ts.findConfigFile(fileName, ts.sys.fileExists)
   });
@@ -49,4 +49,4 @@ export function parseSubstitutionsFile (fileName: string): SubstitutionsMap {
   }
 
   return substitutions;
-}
+};

package/src/protobuf-json.ts

@@ -9,7 +9,7 @@ interface ProtobufJson {
   [K: string]: any
 }
 
-function postprocessProtobufJson (protobufJson: ProtobufJson): ProtobufJson {
+const postprocessProtobufJson = (protobufJson: ProtobufJson): ProtobufJson => {
   if (!protobufJson.nested) {
     return protobufJson;
   }
@@ -22,8 +22,6 @@ function postprocessProtobufJson (protobufJson: ProtobufJson): ProtobufJson {
     ...protobufJson,
     nested: newNested
   };
-}
+};
 
-export function serializeSchemaToJson (root: protobuf.Root): any {
-  return postprocessProtobufJson(root.toJSON({ keepComments: true }));
-}
+export const serializeSchemaToJson = (root: protobuf.Root): any => postprocessProtobufJson(root.toJSON({ keepComments: true }));

package/src/type-generator.ts

@@ -17,12 +17,18 @@ import { parseSubstitutionsFile, registerResolver, SubstitutionsMap } from './pa
 registerResolver();
 preconfigureProtobufjs();
 
-export async function parseAndGenerateSchema (substitutionsModule: ModuleSpecifier | undefined, protoFiles: string[], outDirPath: string) {
+export const parseAndGenerateSchema = async (substitutionsModule: ModuleSpecifier | undefined, protoFiles: string[], outDirPath: string) => {
   const substitutions = substitutionsModule ? parseSubstitutionsFile(substitutionsModule.resolve()) : {};
-  logger.logParsedSubstitutions(substitutions);
-
   const root = await pb.load(protoFiles);
 
+  for (const fqn of Object.keys(substitutions)) {
+    if (!root.lookup(fqn)) {
+      throw new Error(`No protobuf definition found matching the substitution: ${fqn}`);
+    }
+  }
+
+  logger.logParsedSubstitutions(substitutions);
+
   await generateSchema({
     schema: root,
     outDir: outDirPath,
@@ -33,7 +39,7 @@ export async function parseAndGenerateSchema (substitutionsModule: ModuleSpecifi
         }
       : undefined
   });
-}
+};
 
 export interface GenerateSchemaOptions {
   schema: pb.Root
@@ -47,7 +53,7 @@ export interface GenerateSchemaOptions {
 /**
  * Generate typescript definitions for a given schema and write them to `options.outDir`.
  */
-export function generateSchema (options: GenerateSchemaOptions) {
+export const generateSchema = (options: GenerateSchemaOptions) => {
   const namespaces = splitSchemaIntoNamespaces(options.schema);
 
   const printer = ts.createPrinter();
@@ -77,4 +83,4 @@ export function generateSchema (options: GenerateSchemaOptions) {
   const source = printer.printFile(generatedSourceFile);
 
   writeFileSync(join(options.outDir, 'index.ts'), source);
-}
+};

package/src/util.ts

@@ -2,7 +2,7 @@
 // Copyright 2020 DXOS.org
 //
 
-export function getFlags (enumType: any, flags: any) {
+export const getFlags = (enumType: any, flags: any) => {
   const res = [];
   for (const variant of Object.keys(enumType)) {
     if (typeof variant !== 'string') {
@@ -13,4 +13,4 @@ export function getFlags (enumType: any, flags: any) {
     }
   }
   return res;
-}
+};